diff --git a/capmonstercloud_client/CapMonsterCloudClient.py b/capmonstercloud_client/CapMonsterCloudClient.py index 7e4323d..942bbef 100644 --- a/capmonstercloud_client/CapMonsterCloudClient.py +++ b/capmonstercloud_client/CapMonsterCloudClient.py @@ -30,7 +30,9 @@ ((AmazonWafRequest,), getAmazonWafTimeouts), ((BinanceTaskRequest,), getBinanceTimeouts), ((ImpervaCustomTaskRequest,), getImpervaTimeouts), - ((RecognitionComplexImageTaskRequest), getCITTimeouts) + ((RecognitionComplexImageTaskRequest), getCITTimeouts), + ((MTCaptchaRequest), getImage2TextTimeouts), + ((YidunRequest), getImage2TextTimeouts), ) @@ -79,7 +81,9 @@ async def solve_captcha(self, request: Union[ BinanceTaskRequest, ImpervaCustomTaskRequest, TurnstileRequest, - RecognitionComplexImageTaskRequest], + RecognitionComplexImageTaskRequest, + MTCaptchaRequest, + YidunRequest], ) -> Dict[str, str]: ''' Non-blocking method for captcha solving. diff --git a/capmonstercloud_client/requests/DataDomeCustomTaskRequest.py b/capmonstercloud_client/requests/DataDomeCustomTaskRequest.py index fe08e9a..84425e4 100644 --- a/capmonstercloud_client/requests/DataDomeCustomTaskRequest.py +++ b/capmonstercloud_client/requests/DataDomeCustomTaskRequest.py @@ -13,12 +13,8 @@ def validate_metadata(cls, value): if value.get('captchaUrl') and value.get('htmlPageBase64'): raise TypeError(f'Expected only one of [captchaUrl, htmlPageBase64]') elif value.get('captchaUrl'): - if not isinstance(value.get('captchaUrl'), str): - raise TypeError(f'Expect that type imagesUrls array will be , got {type(value.get("captchaUrl"))}') return {i: value[i] for i in value if i != 'htmlPageBase64'} elif value.get('htmlPageBase64'): - if not isinstance(value.get('htmlPageBase64'), str): - raise TypeError(f'Expect that type imagesUrls array will be , got {type(value.get("htmlPageBase64"))}') return {i: value[i] for i in value if i != 'captchaUrl'} else: raise TypeError(f'Expected one of [captchaUrl, htmlPageBase64]') diff --git a/capmonstercloud_client/requests/MTCaptchaRequest.py b/capmonstercloud_client/requests/MTCaptchaRequest.py new file mode 100644 index 0000000..e8f8e59 --- /dev/null +++ b/capmonstercloud_client/requests/MTCaptchaRequest.py @@ -0,0 +1,32 @@ +from typing import Dict, Optional, Union +from pydantic import Field +from .baseRequestWithProxy import BaseRequestWithProxy + + +class MTCaptchaRequest(BaseRequestWithProxy): + type: str = Field(default="MTCaptchaTask") + websiteUrl: str + websiteKey: str + pageAction: Optional[str] = Field(default=None) + isInvisible: Optional[bool] = Field(default=None) + userAgent: Optional[str] = Field(default=None) + + def getTaskDict(self) -> Dict[str, Union[str, int, bool]]: + task = {} + task["type"] = self.type + task["websiteURL"] = self.websiteUrl + task["websiteKey"] = self.websiteKey + if self.pageAction is not None: + task["pageAction"] = self.pageAction + if self.isInvisible is not None: + task["isInvisible"] = self.isInvisible + if self.userAgent is not None: + task["userAgent"] = self.userAgent + if self.proxy: + task["proxyType"] = self.proxy.proxyType + task["proxyAddress"] = self.proxy.proxyAddress + task["proxyPort"] = self.proxy.proxyPort + task["proxyLogin"] = self.proxy.proxyLogin + task["proxyPassword"] = self.proxy.proxyPassword + + return task diff --git a/capmonstercloud_client/requests/TurnstileRequest.py b/capmonstercloud_client/requests/TurnstileRequest.py index 7920bb0..6a525c2 100644 --- a/capmonstercloud_client/requests/TurnstileRequest.py +++ b/capmonstercloud_client/requests/TurnstileRequest.py @@ -1,4 +1,4 @@ -from typing import Dict, Optional +from typing import Dict, Optional, Union from pydantic import Field, validator, model_validator from .baseRequestWithProxy import BaseRequestWithProxy @@ -32,6 +32,11 @@ def validate_cloudflare_type_token(self): raise RuntimeError(f'Expect that "htmlPageBase64" will be filled ' \ f'when cloudflareTaskType is "cf_clearance"') + if self.get('proxy') is None: + if self.get('cloudflareTaskType') == 'cf_clearance': + raise RuntimeError(f'You are working using queries, and you need cf_clearance cookies ' \ + f'it is required that you need your proxies.') + if self.get('cloudflareTaskType') == 'token': for field in ['pageAction', 'pageData', 'data']: if self.get(field) is None: @@ -43,9 +48,34 @@ def validate_cloudflare_type_token(self): if self.get('userAgent') is None: raise RuntimeError(f'Expect that userAgent will be filled ' \ f'when cloudflareTaskType specified.') - + return self - def getTaskDict(self) -> Dict[str, str]: - return {k: v for k, v in self.model_dump().items() if v is not None} + def getTaskDict(self) -> Dict[str, Union[str, int, bool]]: + task = {} + task['type'] = self.type + task['websiteURL'] = self.websiteURL + task['websiteKey'] = self.websiteKey + if self.pageAction is not None: + task['pageAction'] = self.pageAction + if self.data is not None: + task['data'] = self.data + if self.pageData is not None: + task['pageData'] = self.pageData + if self.userAgent is not None: + task['userAgent'] = self.userAgent + if self.cloudflareTaskType is not None: + task['cloudflareTaskType'] = self.cloudflareTaskType + if self.htmlPageBase64 is not None: + task['htmlPageBase64'] = self.htmlPageBase64 + if self.apiJsUrl is not None: + task['apiJsUrl'] = self.apiJsUrl + if self.proxy: + task['proxyType'] = self.proxy.proxyType + task['proxyAddress'] = self.proxy.proxyAddress + task['proxyPort'] = self.proxy.proxyPort + task['proxyLogin'] = self.proxy.proxyLogin + task['proxyPassword'] = self.proxy.proxyPassword + + return task \ No newline at end of file diff --git a/capmonstercloud_client/requests/YidunRequest.py b/capmonstercloud_client/requests/YidunRequest.py new file mode 100644 index 0000000..46352ec --- /dev/null +++ b/capmonstercloud_client/requests/YidunRequest.py @@ -0,0 +1,26 @@ +from typing import Dict, Optional, Union +from pydantic import Field +from .baseRequestWithProxy import BaseRequestWithProxy + + +class YidunRequest(BaseRequestWithProxy): + type: str = Field(default="YidunTask") + websiteUrl: str + websiteKey: str + userAgent: Optional[str] = Field(default=None) + + def getTaskDict(self) -> Dict[str, Union[str, int, bool]]: + task = {} + task["type"] = self.type + task["websiteURL"] = self.websiteUrl + task["websiteKey"] = self.websiteKey + if self.userAgent is not None: + task["userAgent"] = self.userAgent + if self.proxy: + task["proxyType"] = self.proxy.proxyType + task["proxyAddress"] = self.proxy.proxyAddress + task["proxyPort"] = self.proxy.proxyPort + task["proxyLogin"] = self.proxy.proxyLogin + task["proxyPassword"] = self.proxy.proxyPassword + + return task diff --git a/capmonstercloud_client/requests/__init__.py b/capmonstercloud_client/requests/__init__.py index 10acf4c..f4953fd 100644 --- a/capmonstercloud_client/requests/__init__.py +++ b/capmonstercloud_client/requests/__init__.py @@ -18,6 +18,9 @@ from .BinanceTaskRequest import BinanceTaskRequest from .ImpervaCustomTaskRequest import ImpervaCustomTaskRequest from .RecognitionComplexImageTaskRequest import RecognitionComplexImageTaskRequest +from .MTCaptchaRequest import MTCaptchaRequest +from .YidunRequest import YidunRequest +from .proxy_info import ProxyInfo REQUESTS = ['RecaptchaV2EnterpiseRequest', 'RecaptchaV2Request', 'RecaptchaV3ProxylessRequest', 'RecaptchaComplexImageTaskRequest' diff --git a/capmonstercloud_client/version.txt b/capmonstercloud_client/version.txt index a0cd9f0..a4f52a5 100644 --- a/capmonstercloud_client/version.txt +++ b/capmonstercloud_client/version.txt @@ -1 +1 @@ -3.1.0 \ No newline at end of file +3.2.0 \ No newline at end of file diff --git a/test/amazonwaf_response_test.py b/test/amazonwaf_response_test.py deleted file mode 100644 index f59999a..0000000 --- a/test/amazonwaf_response_test.py +++ /dev/null @@ -1,52 +0,0 @@ -import unittest -import asyncio -import os - -from pydantic.error_wrappers import ValidationError -from capmonstercloudclient.requests import AmazonWafRequest -from capmonstercloudclient import CapMonsterClient, ClientOptions - -def get_all_keys(dictionary): - all_values = [] - def recursive_items(dictionary): - for key, value in dictionary.items(): - if type(value) is dict: - all_values.append(key) - recursive_items(value) - else: - all_values.append(key) - return all_values - return recursive_items(dictionary) - -class AmazonWafOutsTest(unittest.TestCase): - - def testOuts(self): - required_outs = ['captcha_voucher', 'existing_token', 'cookies', 'aws-waf-token'] - api_key = os.getenv('API_KEY') - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options) - goku_props = { - "key":"AQIDAHjcYu/GjX+QlghicBgQ/7bFaQZ+m5FKCMDnO+vTbNg96AGmvCkduxEuykZKc0K40UwtAAAAfjB8BgkqhkiG9w0BBwagbzBtAgEAMGgGCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQM+H2/bzoimaPlOij3AgEQgDsAEZjIlq+1m1nBhpIfMKW5CRjtglgrtZVQ1qzzOD12VaRtyo37TyZNSWehn9LZjlsRHCvkEuVNxYrQLQ==", - "iv":"CgAHrDMYFFAAAD69", - "context":"hPWsn2RGeTkDkphwlj11dOk4T2nmJjCUzXFoPnhio4Osqt29lETt0U4/Ie0waoNwuxg/YobRAkPaS4pGC5+XDtSWuEjIOVGEWIrL4icEv19/EuBg1v3Vh0AU+UB/Wk1n63rxlFwU+EwKWjWdkYWFw79vTrr/zrBao1+rzlsKWvrF5CJEJFUvnHz1cU1UQ9M0hBW8diVhKPvf67E9Tf58wwOcNK5tfAX+uhg3G84XpPvh+6bobZleX4Nrz8lER3wNfOcYexyhouErEoowh2DBnnlrsm/OenFFuyRKqgJvHJL7rws=" - } - - challenge = "https://41bcdd4fb3cb.610cd090.us-east-1.token.awswaf.com/41bcdd4fb3cb/0d21de737ccb/cd77baa6c832/challenge.js" - captcha = "https://41bcdd4fb3cb.610cd090.us-east-1.captcha.awswaf.com/41bcdd4fb3cb/0d21de737ccb/cd77baa6c832/captcha.js" - request = AmazonWafRequest(websiteUrl='https://efw47fpad9.execute-api.us-east-1.amazonaws.com/latest', - websiteKey=goku_props['key'], - challengeScript=challenge, - captchaScript=captcha, - context=goku_props['context'], - iv=goku_props['iv'], - cookieSolution=True - ) - result = asyncio.run(client.solve_captcha(request)) - print(result) - # for i in required_outs: - # self.assertTrue(i in get_all_keys(result)) - - -if __name__ == '__main__': - unittest.main() - \ No newline at end of file diff --git a/test/amazonwaf_test.py b/test/amazonwaf_test.py index 0ef17c9..60cfc60 100644 --- a/test/amazonwaf_test.py +++ b/test/amazonwaf_test.py @@ -1,64 +1,75 @@ import unittest from pydantic.error_wrappers import ValidationError + from capmonstercloudclient.requests import AmazonWafRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError + class AmazonWafRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://example.com' - websiteKeyExample = '189123456' - challengeScriptExample = 'challenge_test' - captchaScriptExample = '123' - contextExample = 'context' - ivExample = 'ivexample_`¬' + websiteUrlExample = "https://example.com" + websiteKeyExample = "189123456" + challengeScriptExample = "challenge_test" + captchaScriptExample = "123" + contextExample = "context" + ivExample = "ivexample_`¬" def testCaptchaInputTypes(self): - with self.assertRaises(ValidationError): - request = AmazonWafRequest(websiteUrl=AmazonWafRequestTest.websiteUrlExample) - + request = AmazonWafRequest( + websiteUrl=AmazonWafRequestTest.websiteUrlExample + ) + with self.assertRaises(ValidationError): request = AmazonWafRequest( - websiteKey=AmazonWafRequestTest.websiteKeyExample, - ) + websiteKey=AmazonWafRequestTest.websiteKeyExample, + ) with self.assertRaises(ValidationError): - request = AmazonWafRequest(websiteUrl=AmazonWafRequestTest.websiteUrlExample, - websiteKey=AmazonWafRequestTest.websiteKeyExample, - challengeScript=AmazonWafRequestTest.challengeScriptExample, - captchaScript=int(AmazonWafRequestTest.captchaScriptExample), - context=AmazonWafRequestTest.contextExample, - iv=AmazonWafRequestTest.ivExample - ) - + request = AmazonWafRequest( + websiteUrl=AmazonWafRequestTest.websiteUrlExample, + websiteKey=AmazonWafRequestTest.websiteKeyExample, + challengeScript=AmazonWafRequestTest.challengeScriptExample, + captchaScript=int(AmazonWafRequestTest.captchaScriptExample), + context=AmazonWafRequestTest.contextExample, + iv=AmazonWafRequestTest.ivExample, + ) + + request = AmazonWafRequest( + websiteUrl=AmazonWafRequestTest.websiteUrlExample, + websiteKey=AmazonWafRequestTest.websiteKeyExample, + challengeScript=AmazonWafRequestTest.challengeScriptExample, + captchaScript=AmazonWafRequestTest.captchaScriptExample, + context=AmazonWafRequestTest.contextExample, + iv=AmazonWafRequestTest.ivExample, + ) - request = AmazonWafRequest(websiteUrl=AmazonWafRequestTest.websiteUrlExample, - websiteKey=AmazonWafRequestTest.websiteKeyExample, - challengeScript=AmazonWafRequestTest.challengeScriptExample, - captchaScript=AmazonWafRequestTest.captchaScriptExample, - context=AmazonWafRequestTest.contextExample, - iv=AmazonWafRequestTest.ivExample - ) - def testAllRequiredFieldsFilling(self): - required_fields = ['websiteURL', 'type', 'websiteKey', 'challengeScript', 'captchaScript', - 'context', 'iv'] - request = AmazonWafRequest(websiteUrl=AmazonWafRequestTest.websiteUrlExample, - websiteKey=AmazonWafRequestTest.websiteKeyExample, - challengeScript=AmazonWafRequestTest.challengeScriptExample, - captchaScript=AmazonWafRequestTest.captchaScriptExample, - context=AmazonWafRequestTest.contextExample, - iv=AmazonWafRequestTest.ivExample, - cookieSolution=True - ) + required_fields = [ + "websiteURL", + "type", + "websiteKey", + "challengeScript", + "captchaScript", + "context", + "iv", + ] + request = AmazonWafRequest( + websiteUrl=AmazonWafRequestTest.websiteUrlExample, + websiteKey=AmazonWafRequestTest.websiteKeyExample, + challengeScript=AmazonWafRequestTest.challengeScriptExample, + captchaScript=AmazonWafRequestTest.captchaScriptExample, + context=AmazonWafRequestTest.contextExample, + iv=AmazonWafRequestTest.ivExample, + cookieSolution=True, + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["type"], "AmazonTask") - self.assertEqual(request_dict['type'], 'AmazonTask') - -if __name__ == '__main__': - unittest.main() \ No newline at end of file +if __name__ == "__main__": + unittest.main() diff --git a/test/basilisk_response_test.py b/test/basilisk_response_test.py deleted file mode 100644 index efd9fa5..0000000 --- a/test/basilisk_response_test.py +++ /dev/null @@ -1,38 +0,0 @@ -import unittest -import asyncio -import os - -from pydantic.error_wrappers import ValidationError -from capmonstercloudclient.requests import BasiliskCustomTaskProxylessRequest -from capmonstercloudclient import CapMonsterClient, ClientOptions - -def get_all_keys(dictionary): - all_values = [] - def recursive_items(dictionary): - for key, value in dictionary.items(): - if type(value) is dict: - all_values.append(key) - recursive_items(value) - else: - all_values.append(key) - return all_values - return recursive_items(dictionary) - -class BasiliskOutsTest(unittest.TestCase): - - def testOuts(self): - required_outs = ['domains', 'fingerprint', 'headers', 'data', 'captcha_response'] - api_key = os.getenv('API_KEY') - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options) - - request = BasiliskCustomTaskProxylessRequest(websiteUrl='https://faucetpay.io/account/register', - websiteKey='a3760bfe5cf4254b2759c19fb2601667') - result = asyncio.run(client.solve_captcha(request)) - for i in required_outs: - self.assertTrue(i in get_all_keys(result)) - - -if __name__ == '__main__': - unittest.main() - \ No newline at end of file diff --git a/test/basilisk_test.py b/test/basilisk_test.py index 1312663..499b11f 100644 --- a/test/basilisk_test.py +++ b/test/basilisk_test.py @@ -1,44 +1,48 @@ import unittest from pydantic.error_wrappers import ValidationError + from capmonstercloudclient.requests import BasiliskCustomTaskRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError + class BasiliskCustomTaskRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://example.com' - websiteKeyExample = '189123456' - userAgentExample = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36' + websiteUrlExample = "https://example.com" + websiteKeyExample = "189123456" + userAgentExample = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" def testCaptchaInputTypes(self): - with self.assertRaises(ValidationError): - request = BasiliskCustomTaskRequest(websiteUrl=BasiliskCustomTaskRequestTest.websiteUrlExample) - + request = BasiliskCustomTaskRequest( + websiteUrl=BasiliskCustomTaskRequestTest.websiteUrlExample + ) + with self.assertRaises(ValidationError): request = BasiliskCustomTaskRequest( - websiteKey=BasiliskCustomTaskRequestTest.websiteKeyExample, - ) - - - request = BasiliskCustomTaskRequest(websiteUrl=BasiliskCustomTaskRequestTest.websiteUrlExample, - websiteKey=BasiliskCustomTaskRequestTest.websiteKeyExample, - userAgent=BasiliskCustomTaskRequestTest.userAgentExample - ) - + websiteKey=BasiliskCustomTaskRequestTest.websiteKeyExample, + ) + + request = BasiliskCustomTaskRequest( + websiteUrl=BasiliskCustomTaskRequestTest.websiteUrlExample, + websiteKey=BasiliskCustomTaskRequestTest.websiteKeyExample, + userAgent=BasiliskCustomTaskRequestTest.userAgentExample, + ) + def testAllRequiredFieldsFilling(self): - required_fields = ['class', 'type', 'websiteURL', 'websiteKey'] - request = BasiliskCustomTaskRequest(websiteUrl=BasiliskCustomTaskRequestTest.websiteUrlExample, - websiteKey=BasiliskCustomTaskRequestTest.websiteKeyExample) + required_fields = ["class", "type", "websiteURL", "websiteKey"] + request = BasiliskCustomTaskRequest( + websiteUrl=BasiliskCustomTaskRequestTest.websiteUrlExample, + websiteKey=BasiliskCustomTaskRequestTest.websiteKeyExample, + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["class"], "Basilisk") + self.assertEqual(request_dict["type"], "CustomTask") - self.assertEqual(request_dict['class'], 'Basilisk') - self.assertEqual(request_dict['type'], 'CustomTask') - -if __name__ == '__main__': - unittest.main() \ No newline at end of file +if __name__ == "__main__": + unittest.main() diff --git a/test/binance_request_test.py b/test/binance_request_test.py deleted file mode 100644 index 390646e..0000000 --- a/test/binance_request_test.py +++ /dev/null @@ -1,45 +0,0 @@ -import unittest -from copy import deepcopy - -from pydantic import ValidationError -from capmonstercloudclient.requests import BinanceTaskRequest - - -class BinanceRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://binance.com/login' - websiteKeyExample = 'login' - userAgentExample = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36' - - def test_binance(self, - ): - required_fields = ['type', - 'websiteURL', - 'websiteKey', - 'validateId'] - request = BinanceTaskRequest(websiteKey=self.websiteKeyExample, - websiteUrl=self.websiteUrlExample, - validateId='asdgf') - task_dictionary = request.getTaskDict() - for f in required_fields: - self.assertTrue(f in list(task_dictionary.keys()), - msg=f'Required captcha input key "{f}" does not include to request.') - - def test_binance_missing(self,): - required_fields = ['type', - 'websiteURL', - 'websiteKey', - 'validateId'] - base_kwargs = {} - self.assertRaises(ValidationError, BinanceTaskRequest, **base_kwargs) - base_kwargs.update({'websiteUrl': self.websiteUrlExample}) - self.assertRaises(ValidationError, BinanceTaskRequest, **base_kwargs) - base_kwargs.update({'websiteKey': self.websiteKeyExample}) - self.assertRaises(ValidationError, BinanceTaskRequest, **base_kwargs) - base_kwargs.update({'validateId': 'asdgf'}) - BinanceTaskRequest(**base_kwargs) - base_kwargs.update({'userAgent': self.userAgentExample}) - BinanceTaskRequest(**base_kwargs) - -if __name__ == '__main__': - unittest.main() \ No newline at end of file diff --git a/test/binance_response_test.py b/test/binance_response_test.py deleted file mode 100644 index 54cdb6f..0000000 --- a/test/binance_response_test.py +++ /dev/null @@ -1,60 +0,0 @@ -import unittest -import asyncio -import os - -from pydantic.error_wrappers import ValidationError -from capmonstercloudclient.requests import BinanceTaskRequest -from capmonstercloudclient import CapMonsterClient, ClientOptions -from capmonstercloudclient.requests.proxy_info import ProxyInfo - -def get_all_keys(dictionary): - all_values = [] - def recursive_items(dictionary): - for key, value in dictionary.items(): - if type(value) is dict: - all_values.append(key) - recursive_items(value) - else: - all_values.append(key) - return all_values - return recursive_items(dictionary) - -class AmazonWafOutsTest(unittest.TestCase): - - def testOuts(self): - required_outs = ['token', 'userAgent'] - api_key = os.getenv('API_KEY') - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options) - request = BinanceTaskRequest(websiteUrl='https://accounts.binance.com/ru/login?loginChannel=&return_to=', - websiteKey='login', - validateId="2b8137c0b9b44189800368819354e114" - ) - result = asyncio.run(client.solve_captcha(request)) - for i in required_outs: - self.assertTrue(i in get_all_keys(result)) - - def testOutsProxy(self): - required_outs = ['token', 'userAgent'] - api_key = os.getenv('API_KEY') - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options) - proxy = ProxyInfo(proxyType='https', - proxyAddress='proxyAddress', - proxyPort=8000, - proxyLogin='proxyLogin', - proxyPassword='proxyPassword' - ) - request = BinanceTaskRequest(websiteUrl='https://accounts.binance.com/ru/login?loginChannel=&return_to=', - websiteKey='login', - validateId="2b8137c0b9b44189800368819354e114", - proxy=proxy - ) - result = asyncio.run(client.solve_captcha(request)) - for i in required_outs: - self.assertTrue(i in get_all_keys(result)) - - -if __name__ == '__main__': - unittest.main() - \ No newline at end of file diff --git a/test/binance_test.py b/test/binance_test.py new file mode 100644 index 0000000..c05263a --- /dev/null +++ b/test/binance_test.py @@ -0,0 +1,46 @@ +import unittest + +from pydantic import ValidationError + +from capmonstercloudclient.requests import BinanceTaskRequest + + +class BinanceRequestTest(unittest.TestCase): + websiteUrlExample = "https://binance.com/login" + websiteKeyExample = "login" + userAgentExample = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" + + def test_binance( + self, + ): + required_fields = ["type", "websiteURL", "websiteKey", "validateId"] + request = BinanceTaskRequest( + websiteKey=self.websiteKeyExample, + websiteUrl=self.websiteUrlExample, + validateId="asdgf", + ) + task_dictionary = request.getTaskDict() + for f in required_fields: + self.assertTrue( + f in list(task_dictionary.keys()), + msg=f'Required captcha input key "{f}" does not include to request.', + ) + + def test_binance_missing( + self, + ): + required_fields = ["type", "websiteURL", "websiteKey", "validateId"] + base_kwargs = {} + self.assertRaises(ValidationError, BinanceTaskRequest, **base_kwargs) + base_kwargs.update({"websiteUrl": self.websiteUrlExample}) + self.assertRaises(ValidationError, BinanceTaskRequest, **base_kwargs) + base_kwargs.update({"websiteKey": self.websiteKeyExample}) + self.assertRaises(ValidationError, BinanceTaskRequest, **base_kwargs) + base_kwargs.update({"validateId": "asdgf"}) + BinanceTaskRequest(**base_kwargs) + base_kwargs.update({"userAgent": self.userAgentExample}) + BinanceTaskRequest(**base_kwargs) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/cit_test.py b/test/cit_test.py index 1a1544e..6782662 100644 --- a/test/cit_test.py +++ b/test/cit_test.py @@ -3,69 +3,96 @@ import base64 from pydantic.error_wrappers import ValidationError from capmonstercloudclient.requests import RecognitionComplexImageTaskRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError +from capmonstercloudclient.exceptions import ( + TaskNotDefinedError, + ZeroImagesErrors, +) -def read_image(image_url: str,): + +def read_image( + image_url: str, +): image_bytes = urllib.request.urlopen(image_url).read() - return base64.b64encode(image_bytes).decode('utf-8') + return base64.b64encode(image_bytes).decode("utf-8") + class RecognitionCITImageRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=middle' - imageUrlsExamples = ['https://i.postimg.cc/H8yBD5FJ/0-2.png', 'https://i.postimg.cc/rz0hrXz8/0-0.png', - 'https://i.postimg.cc/qgP1cbC2/0-1.png'] + websiteUrlExample = ( + "https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=middle" + ) + imageUrlsExamples = [ + "https://i.postimg.cc/H8yBD5FJ/0-2.png", + "https://i.postimg.cc/rz0hrXz8/0-0.png", + "https://i.postimg.cc/qgP1cbC2/0-1.png", + ] imageBase64Examples = [read_image(i) for i in imageUrlsExamples] metadataExample = {"Task": "oocl_rotate_double_new"} - + def testImagesTypes(self): - with self.assertRaises(ValidationError): - request = RecognitionComplexImageTaskRequest(metadata=RecognitionCITImageRequestTest.metadataExample, - imagesBase64='[]') - - + request = RecognitionComplexImageTaskRequest( + metadata=RecognitionCITImageRequestTest.metadataExample, + imagesBase64="[]", + ) + def testImagesFilling(self): - - with self.assertRaises(ZeroImagesErrors, - msg='Empty array imagesBase64 must be cause ZeroImagesErrors'): - request = RecognitionComplexImageTaskRequest(metadata=RecognitionCITImageRequestTest.metadataExample, - imagesBase64=[]) - + with self.assertRaises( + ZeroImagesErrors, + msg="Empty array imagesBase64 must be cause ZeroImagesErrors", + ): + request = RecognitionComplexImageTaskRequest( + metadata=RecognitionCITImageRequestTest.metadataExample, imagesBase64=[] + ) + def testAllRequiredFieldsFilling(self): - required_fields = ['class', 'type', 'metadata'] - metadata_fields = ['Task'] + required_fields = ["class", "type", "metadata"] + metadata_fields = ["Task"] request = RecognitionComplexImageTaskRequest( - metadata=RecognitionCITImageRequestTest.metadataExample, - imagesBase64=RecognitionCITImageRequestTest.imageBase64Examples) + metadata=RecognitionCITImageRequestTest.metadataExample, + imagesBase64=RecognitionCITImageRequestTest.imageBase64Examples, + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - - metadata_dict = request_dict['metadata'] + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + metadata_dict = request_dict["metadata"] for i in metadata_fields: - self.assertTrue(i in list(metadata_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - - self.assertEqual(request_dict['class'], 'recognition') - self.assertEqual(request_dict['type'], 'ComplexImageTask') - + self.assertTrue( + i in list(metadata_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["class"], "recognition") + self.assertEqual(request_dict["type"], "ComplexImageTask") + def testTaskDefined(self): - with self.assertRaises(TaskNotDefinedError, - msg='Expect that empty "Task" field will be cause TaskNotDefinedError'): - request = RecognitionComplexImageTaskRequest(metadata={}, - imagesBase64=RecognitionCITImageRequestTest.imageBase64Examples) - + with self.assertRaises( + TaskNotDefinedError, + msg='Expect that empty "Task" field will be cause TaskNotDefinedError', + ): + request = RecognitionComplexImageTaskRequest( + metadata={}, + imagesBase64=RecognitionCITImageRequestTest.imageBase64Examples, + ) + with self.assertRaises(TaskNotDefinedError): - request = RecognitionComplexImageTaskRequest(metadata={'dsfsdf': 'sdfsdf'}, - imagesUrls=RecognitionCITImageRequestTest.imageUrlsExamples) + request = RecognitionComplexImageTaskRequest( + metadata={"dsfsdf": "sdfsdf"}, + imagesUrls=RecognitionCITImageRequestTest.imageUrlsExamples, + ) def testExtraMetadata(self): - with self.assertRaises(TypeError, - msg='Expect that extra metadata fields will be cause TypeError'): - request = RecognitionComplexImageTaskRequest(metadata={"Task": "oocl_rotate_new", 'asd': 'asd'}, - imagesBase64=RecognitionCITImageRequestTest.imageBase64Examples) - -if __name__ == '__main__': - unittest.main() \ No newline at end of file + with self.assertRaises( + TypeError, msg="Expect that extra metadata fields will be cause TypeError" + ): + request = RecognitionComplexImageTaskRequest( + metadata={"Task": "oocl_rotate_new", "asd": "asd"}, + imagesBase64=RecognitionCITImageRequestTest.imageBase64Examples, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/cmclient_test.py b/test/cmclient_test.py index d970668..5e5562c 100644 --- a/test/cmclient_test.py +++ b/test/cmclient_test.py @@ -7,27 +7,31 @@ from capmonstercloudclient.exceptions import UnknownRequestInstanceError -api_key = os.getenv('API_KEY') +api_key = os.getenv("API_KEY") class InstanceRequestTest(unittest.IsolatedAsyncioTestCase): - def testSuccessResponse(self): options = ClientOptions(api_key=api_key) client = CapMonsterClient(options=options) - request = RecaptchaV2Request(websiteUrl="https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high", - websiteKey="6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd") + request = RecaptchaV2Request( + websiteUrl="https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high", + websiteKey="6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd", + ) # Success response_1 = asyncio.run(client.solve_captcha(request)) self.assertTrue(isinstance(response_1, dict)) - + def testFailedInstanceRequest(self): options = ClientOptions(api_key=api_key) client = CapMonsterClient(options=options) # Failed - with self.assertRaises(UnknownRequestInstanceError, msg='Unknown instance of request must call .'): - asyncio.run(client.solve_captcha('hmmm')) + with self.assertRaises( + UnknownRequestInstanceError, + msg="Unknown instance of request must call .", + ): + asyncio.run(client.solve_captcha("hmmm")) -if __name__ == '__main__': - unittest.main() \ No newline at end of file +if __name__ == "__main__": + unittest.main() diff --git a/test/datadome_response_test.py b/test/datadome_response_test.py deleted file mode 100644 index c36c59d..0000000 --- a/test/datadome_response_test.py +++ /dev/null @@ -1,41 +0,0 @@ -import unittest -import asyncio -import os - -from pydantic.error_wrappers import ValidationError -from capmonstercloudclient.requests import DataDomeCustomTaskRequest -from capmonstercloudclient import CapMonsterClient, ClientOptions - -def get_all_keys(dictionary): - all_values = [] - def recursive_items(dictionary): - for key, value in dictionary.items(): - if type(value) is dict: - all_values.append(key) - recursive_items(value) - else: - all_values.append(key) - return all_values - return recursive_items(dictionary) - -class DataDomeOutsTest(unittest.TestCase): - - def testOuts(self): - required_outs = ['domains', 'datadome', 'cookies'] - api_key = os.getenv('API_KEY') - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options) - metadata = {'captchaUrl': 'https://geo.captcha-delivery.com/captcha/?initialCid=AHrlqAAAAAMAJxx4dfgwjzwAQW0ctQ%3D%3D&hash=D66B23AC3F48A302A7654416846381&cid=d3k5rbDsu8cq0kmPHISS3hsC3f4qeL_K12~G33PrE4fbkmDYSul6l0Ze_aG5sUHLKG0676UpTv6GFvUgIActglZF33GTodOoRhEDkMMsuWTodlYa3YYQ9xKy9J89PAWh&t=fe&referer=https%3A%2F%2Fantoinevastel.com%2Fbots%2Fdatadome&s=21705&e=04fc682817ba89bf8fa4b18031fa53294fa0fb7449d95c036a1986413e6dfc7d', - 'datadomeCookie': 'datadome=d3k5rbDsu8cq0kmPHISS3hsC3f4qeL_K12~G33PrE4fbkmDYSul6l0Ze_aG5sUHLKG0676UpTv6GFvUgIActglZF33GTodOoRhEDkMMsuWTodlYa3YYQ9xKy9J89PAWh'} - - request = DataDomeCustomTaskRequest(websiteUrl='https://antoinevastel.com/bots/datadome', - metadata=metadata) - result = asyncio.run(client.solve_captcha(request)) - - for i in required_outs: - self.assertTrue(i in get_all_keys(result)) - - -if __name__ == '__main__': - unittest.main() - \ No newline at end of file diff --git a/test/datadome_test.py b/test/datadome_test.py index 2ebaaaf..daea79e 100644 --- a/test/datadome_test.py +++ b/test/datadome_test.py @@ -2,63 +2,71 @@ from pydantic.error_wrappers import ValidationError from capmonstercloudclient.requests import DataDomeCustomTaskRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError + class DataDomeCustomTaskRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://antoinevastel.com/bots/datadome' - metadataExample = {'captchaUrl': 'https://geo.captcha-delivery.com/captcha/?initialCid=AHrlqAAAAAMAJxx4dfgwjzwAQW0ctQ%3D%3D&hash=D66B23AC3F48A302A7654416846381&cid=d3k5rbDsu8cq0kmPHISS3hsC3f4qeL_K12~G33PrE4fbkmDYSul6l0Ze_aG5sUHLKG0676UpTv6GFvUgIActglZF33GTodOoRhEDkMMsuWTodlYa3YYQ9xKy9J89PAWh&t=fe&referer=https%3A%2F%2Fantoinevastel.com%2Fbots%2Fdatadome&s=21705&e=04fc682817ba89bf8fa4b18031fa53294fa0fb7449d95c036a1986413e6dfc7d', - 'datadomeCookie': 'datadome=d3k5rbDsu8cq0kmPHISS3hsC3f4qeL_K12~G33PrE4fbkmDYSul6l0Ze_aG5sUHLKG0676UpTv6GFvUgIActglZF33GTodOoRhEDkMMsuWTodlYa3YYQ9xKy9J89PAWh'} - + websiteUrlExample = "https://antoinevastel.com/bots/datadome" + metadataExample = { + "captchaUrl": "https://geo.captcha-delivery.com/captcha/?initialCid=AHrlqAAAAAMAJxx4dfgwjzwAQW0ctQ%3D%3D&hash=D66B23AC3F48A302A7654416846381&cid=d3k5rbDsu8cq0kmPHISS3hsC3f4qeL_K12~G33PrE4fbkmDYSul6l0Ze_aG5sUHLKG0676UpTv6GFvUgIActglZF33GTodOoRhEDkMMsuWTodlYa3YYQ9xKy9J89PAWh&t=fe&referer=https%3A%2F%2Fantoinevastel.com%2Fbots%2Fdatadome&s=21705&e=04fc682817ba89bf8fa4b18031fa53294fa0fb7449d95c036a1986413e6dfc7d", + "datadomeCookie": "datadome=d3k5rbDsu8cq0kmPHISS3hsC3f4qeL_K12~G33PrE4fbkmDYSul6l0Ze_aG5sUHLKG0676UpTv6GFvUgIActglZF33GTodOoRhEDkMMsuWTodlYa3YYQ9xKy9J89PAWh", + } + def testCaptchaInputTypes(self): - metadataListUrl = DataDomeCustomTaskRequestTest.metadataExample.copy() - metadataListUrl['captchaUrl'] = list(metadataListUrl['captchaUrl']) + metadataListUrl["captchaUrl"] = list(metadataListUrl["captchaUrl"]) metadataListImage = DataDomeCustomTaskRequestTest.metadataExample.copy() - metadataListImage.pop('captchaUrl') - metadataListImage['htmlPageBase64'] = metadataListUrl['captchaUrl'] - + metadataListImage.pop("captchaUrl") + metadataListImage["htmlPageBase64"] = metadataListUrl["captchaUrl"] + metadataListExtra = DataDomeCustomTaskRequestTest.metadataExample.copy() - metadataListExtra['htmlPageBase64'] = metadataListExtra['captchaUrl'] + metadataListExtra["htmlPageBase64"] = metadataListExtra["captchaUrl"] with self.assertRaises(ValidationError): - request = DataDomeCustomTaskRequest(websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, - metadata=metadataListUrl, - ) - - with self.assertRaises(ValidationError): - request = DataDomeCustomTaskRequest(websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, - metadata=metadataListImage, - ) - + request = DataDomeCustomTaskRequest( + websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, + metadata=metadataListUrl, + ) + with self.assertRaises(ValidationError): - request = DataDomeCustomTaskRequest(websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, - metadata=metadataListExtra, - ) - + request = DataDomeCustomTaskRequest( + websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, + metadata=metadataListImage, + ) + + with self.assertRaises(TypeError): + request = DataDomeCustomTaskRequest( + websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, + metadata=metadataListExtra, + ) + def testAllRequiredFieldsFilling(self): - required_fields = ['class', 'type', 'websiteURL', 'metadata'] - metadata_fields = ['datadomeCookie'] - one_of_fields = [['captchaUrl', 'htmlPageBase64']] - request = DataDomeCustomTaskRequest(websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, - metadata=DataDomeCustomTaskRequestTest.metadataExample) + required_fields = ["class", "type", "websiteURL", "metadata"] + metadata_fields = ["datadomeCookie"] + one_of_fields = [["captchaUrl", "htmlPageBase64"]] + request = DataDomeCustomTaskRequest( + websiteUrl=DataDomeCustomTaskRequestTest.websiteUrlExample, + metadata=DataDomeCustomTaskRequestTest.metadataExample, + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - - metadata_dict = request_dict['metadata'] + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + metadata_dict = request_dict["metadata"] for i in metadata_fields: - self.assertTrue(i in list(metadata_dict.keys()), - msg=f'Required field {i} not in {request_dict}') + self.assertTrue( + i in list(metadata_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) for i in one_of_fields: - self.assertTrue(len(set(i).intersection(metadata_dict.keys())) == 1) + self.assertTrue(len(set(i).intersection(metadata_dict.keys())) == 1) + + self.assertEqual(request_dict["class"], "DataDome") + self.assertEqual(request_dict["type"], "CustomTask") - self.assertEqual(request_dict['class'], 'DataDome') - self.assertEqual(request_dict['type'], 'CustomTask') - -if __name__ == '__main__': - unittest.main() \ No newline at end of file +if __name__ == "__main__": + unittest.main() diff --git a/test/fc_image_test.py b/test/fc_image_test.py index d525e17..ed5ee2c 100644 --- a/test/fc_image_test.py +++ b/test/fc_image_test.py @@ -2,105 +2,143 @@ from pydantic.error_wrappers import ValidationError from capmonstercloudclient.requests import FunCaptchaComplexImageTaskRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError +from capmonstercloudclient.exceptions import ( + NumbersImagesErrors, + TaskNotDefinedError, + ZeroImagesErrors, + UserAgentNotDefinedError, +) + class RecaptchaImageRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=middle' + websiteUrlExample = ( + "https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=middle" + ) imageUrlsExamples = ["https://i.postimg.cc/s2ZDrHXy/fc1.jpg"] - metadataExample = {'Task': 'Pick the image that is the correct way up'} - + metadataExample = {"Task": "Pick the image that is the correct way up"} + def testImagesTypes(self): - with self.assertRaises(ValidationError): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesBase64='[]') - + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesBase64="[]", + ) + with self.assertRaises(ValidationError): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls='[]') - + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls="[]", + ) + def testImagesFilling(self): - - with self.assertRaises(ZeroImagesErrors, - msg='Empty array imagesUrls must be cause ZeroImagesErrors'): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=[], - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - - with self.assertRaises(ZeroImagesErrors, - msg='Empty array imagesBase64 must be cause ZeroImagesErrors'): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesBase64=[]) - - with self.assertRaises(ZeroImagesErrors, - msg='Both empty arrays imagesBase64 and imagesUrls must be cause ZeroImagesErrors'): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample) + with self.assertRaises( + ZeroImagesErrors, + msg="Empty array imagesUrls must be cause ZeroImagesErrors", + ): + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=[], + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + with self.assertRaises( + ZeroImagesErrors, + msg="Empty array imagesBase64 must be cause ZeroImagesErrors", + ): + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesBase64=[], + ) + + with self.assertRaises( + ZeroImagesErrors, + msg="Both empty arrays imagesBase64 and imagesUrls must be cause ZeroImagesErrors", + ): + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + ) request.getTaskDict() - + def testNumbersImages(self): - - with self.assertRaises(NumbersImagesErrors, - msg='Empty array must be cause ZeroImagesErrors'): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples*2, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - - - with self.assertRaises(NumbersImagesErrors, - msg='Empty array must be cause ZeroImagesErrors'): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesBase64=['base64image']*2, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - + with self.assertRaises( + NumbersImagesErrors, msg="Empty array must be cause ZeroImagesErrors" + ): + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples * 2, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + with self.assertRaises( + NumbersImagesErrors, msg="Empty array must be cause ZeroImagesErrors" + ): + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesBase64=["base64image"] * 2, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + def testAllRequiredFieldsFilling(self): - required_fields = ['class', 'type', 'websiteUrl', 'metadata', 'userAgent'] - metadata_fields = ['Task'] - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") + required_fields = ["class", "type", "websiteUrl", "metadata", "userAgent"] + metadata_fields = ["Task"] + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - - metadata_dict = request_dict['metadata'] + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + metadata_dict = request_dict["metadata"] for i in metadata_fields: - self.assertTrue(i in list(metadata_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - - self.assertEqual(request_dict['class'], 'funcaptcha') - self.assertEqual(request_dict['type'], 'ComplexImageTask') - + self.assertTrue( + i in list(metadata_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["class"], "funcaptcha") + self.assertEqual(request_dict["type"], "ComplexImageTask") + def testTaskDefined(self): - with self.assertRaises(TaskNotDefinedError, - msg='Expect that empty "Task" field will be cause TaskNotDefinedError'): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata={}, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples) - + with self.assertRaises( + TaskNotDefinedError, + msg='Expect that empty "Task" field will be cause TaskNotDefinedError', + ): + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata={}, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + ) + with self.assertRaises(TaskNotDefinedError): - request = FunCaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata={'dsfsdf': 'sdfsdf'}, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - - @unittest.skip('Doesnt work right now') + request = FunCaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata={"dsfsdf": "sdfsdf"}, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + @unittest.skip("Doesnt work right now") def testUserAgentWithUrl(self): with self.assertRaises(UserAgentNotDefinedError): - request = FunCaptchaComplexImageTaskRequest(metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples) + request = FunCaptchaComplexImageTaskRequest( + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + ) request.getTaskDict() - -if __name__ == '__main__': - unittest.main() \ No newline at end of file + +if __name__ == "__main__": + unittest.main() diff --git a/test/geetest_integration_test.py b/test/geetest_integration_test.py deleted file mode 100644 index 7483d42..0000000 --- a/test/geetest_integration_test.py +++ /dev/null @@ -1,33 +0,0 @@ -import os -import asyncio -import unittest - -from capmonstercloudclient.requests import GeetestRequest -from capmonstercloudclient import ClientOptions, CapMonsterClient - - -def solve(client: CapMonsterClient, request: GeetestRequest): - return asyncio.run(client.solve_captcha(request)) - -class GeeTestIntegrationTest(unittest.TestCase): - - api_key = os.getenv('API_KEY') - client_options = ClientOptions(api_key=api_key) - cap_monster_client = CapMonsterClient(options=client_options) - - def test_check_response_outputs(self): - - required_keys = ['captcha_id', 'lot_number', 'pass_token', 'gen_time', 'captcha_output'] - geetest_request = GeetestRequest(websiteUrl="https://faucetpay.io/account/login", - gt='4eb8b0c2b27f3365b9244d9da81638c6', - version=4, - initParameters={'riskType ': 'slide'}, - ) - response = solve(self.cap_monster_client, geetest_request) - for key in required_keys: - self.assertTrue(key in list(response.keys()), - msg=f'Required captcha output key "{key}" doesnt include to response.') - - -if __name__ == '__main__': - unittest.main() \ No newline at end of file diff --git a/test/hc_image_test.py b/test/hc_image_test.py index 55f8071..d224888 100644 --- a/test/hc_image_test.py +++ b/test/hc_image_test.py @@ -2,114 +2,157 @@ from pydantic.error_wrappers import ValidationError from capmonstercloudclient.requests import HcaptchaComplexImageTaskRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError +from capmonstercloudclient.exceptions import ( + NumbersImagesErrors, + TaskNotDefinedError, + ZeroImagesErrors, + UserAgentNotDefinedError, +) + class HcaptchaImageRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://lessons.zennolab.com/captchas/hcaptcha/?level=easy' - imageUrlsExamples = ["https://i.postimg.cc/kg71cbRt/image-1.jpg", - "https://i.postimg.cc/6381Zx2j/image.jpg"] - metadataExample = {'Task': 'Please click each image containing a mountain'} - + websiteUrlExample = "https://lessons.zennolab.com/captchas/hcaptcha/?level=easy" + imageUrlsExamples = [ + "https://i.postimg.cc/kg71cbRt/image-1.jpg", + "https://i.postimg.cc/6381Zx2j/image.jpg", + ] + metadataExample = {"Task": "Please click each image containing a mountain"} + def testImagesTypes(self): - with self.assertRaises(ValidationError): - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample, - imagesBase64='[]') - + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + imagesBase64="[]", + ) + with self.assertRaises(ValidationError): - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample, - imagesUrls='[]', - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + imagesUrls="[]", + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + def testImagesFilling(self): - - with self.assertRaises(ZeroImagesErrors, - msg='Empty array imagesUrls must be cause ZeroImagesErrors'): - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample, - imagesUrls=[], - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - - with self.assertRaises(ZeroImagesErrors, - msg='Empty array imagesBase64 must be cause ZeroImagesErrors'): - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample, - imagesBase64=[]) - - with self.assertRaises(ZeroImagesErrors, - msg='Both empty arrays imagesBase64 and imagesUrls must be cause ZeroImagesErrors'): - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample) + with self.assertRaises( + ZeroImagesErrors, + msg="Empty array imagesUrls must be cause ZeroImagesErrors", + ): + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + imagesUrls=[], + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + with self.assertRaises( + ZeroImagesErrors, + msg="Empty array imagesBase64 must be cause ZeroImagesErrors", + ): + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + imagesBase64=[], + ) + + with self.assertRaises( + ZeroImagesErrors, + msg="Both empty arrays imagesBase64 and imagesUrls must be cause ZeroImagesErrors", + ): + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + ) request.getTaskDict() - + def testNumbersImages(self): - - with self.assertRaises(NumbersImagesErrors, - msg='Empty array must be cause ZeroImagesErrors'): - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample, - imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples*20, - # userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", - ) - - - with self.assertRaises(NumbersImagesErrors, - msg='Empty array must be cause ZeroImagesErrors'): - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample, - imagesBase64=['base64image']*19) - + with self.assertRaises( + NumbersImagesErrors, msg="Empty array must be cause ZeroImagesErrors" + ): + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples * 20, + # userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + with self.assertRaises( + NumbersImagesErrors, msg="Empty array must be cause ZeroImagesErrors" + ): + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + imagesBase64=["base64image"] * 19, + ) + def testAllRequiredFieldsFilling(self): - required_fields = ['class', 'type', 'websiteUrl', 'metadata'] - request = HcaptchaComplexImageTaskRequest(websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, - metadata=HcaptchaImageRequestTest.metadataExample, - imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples, - # userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", - ) + required_fields = ["class", "type", "websiteUrl", "metadata"] + request = HcaptchaComplexImageTaskRequest( + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + metadata=HcaptchaImageRequestTest.metadataExample, + imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples, + # userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + def testTaskDefined(self): - with self.assertRaises(TaskNotDefinedError, - msg='Expect that empty "Task" field will be cause TaskNotDefinedError'): - request = HcaptchaComplexImageTaskRequest(imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples, - metadata={}, - # userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", - ) - - @unittest.skip('Doesnt work right now') + with self.assertRaises( + TaskNotDefinedError, + msg='Expect that empty "Task" field will be cause TaskNotDefinedError', + ): + request = HcaptchaComplexImageTaskRequest( + imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples, + metadata={}, + # userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + @unittest.skip("Doesnt work right now") def testUserAgentWithUrl(self): with self.assertRaises(UserAgentNotDefinedError): - request = HcaptchaComplexImageTaskRequest(metadata=HcaptchaImageRequestTest.metadataExample, - imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples) + request = HcaptchaComplexImageTaskRequest( + metadata=HcaptchaImageRequestTest.metadataExample, + imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples, + ) request.getTaskDict() - + def testSuccessRequestDict(self): - required_fields = ['class', 'type', 'websiteUrl', 'metadata', 'imageUrls', 'userAgent'] - required_metadata = ['Task'] - request = HcaptchaComplexImageTaskRequest(metadata=HcaptchaImageRequestTest.metadataExample, - imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", - websiteUrl=HcaptchaImageRequestTest.websiteUrlExample) + required_fields = [ + "class", + "type", + "websiteUrl", + "metadata", + "imageUrls", + "userAgent", + ] + required_metadata = ["Task"] + request = HcaptchaComplexImageTaskRequest( + metadata=HcaptchaImageRequestTest.metadataExample, + imagesUrls=HcaptchaImageRequestTest.imageUrlsExamples, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + websiteUrl=HcaptchaImageRequestTest.websiteUrlExample, + ) body = request.getTaskDict() keys = list(body.keys()) - metadata_keys = list(body['metadata'].keys()) - + metadata_keys = list(body["metadata"].keys()) + for rf in required_fields: self.assertTrue(rf in keys) for rm in required_metadata: self.assertTrue(rm in metadata_keys) - - self.assertEqual(HcaptchaImageRequestTest.metadataExample[required_metadata[0]], - body['metadata']['Task']) - self.assertEqual(body['class'], 'hcaptcha') - self.assertEqual(body['type'], 'ComplexImageTask') - -if __name__ == '__main__': - unittest.main() \ No newline at end of file + + self.assertEqual( + HcaptchaImageRequestTest.metadataExample[required_metadata[0]], + body["metadata"]["Task"], + ) + self.assertEqual(body["class"], "hcaptcha") + self.assertEqual(body["type"], "ComplexImageTask") + + +if __name__ == "__main__": + unittest.main() diff --git a/test/hc_response_test.py b/test/hc_response_test.py deleted file mode 100644 index a9c706b..0000000 --- a/test/hc_response_test.py +++ /dev/null @@ -1,25 +0,0 @@ -import unittest -import asyncio -import os - -from pydantic.error_wrappers import ValidationError -from capmonstercloudclient.requests import HcaptchaRequest -from capmonstercloudclient import CapMonsterClient, ClientOptions - -class HcaptchaOutsTest(unittest.TestCase): - - def testOuts(self): - required_outs = ['gRecaptchaResponse', 'userAgent', 'respKey'] - api_key = os.getenv('API_KEY') - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options) - request = HcaptchaRequest(websiteUrl='https://lessons.zennolab.com/captchas/hcaptcha/?level=difficult', - websiteKey='b744cfe0-50b1-455e-90ac-5e5a09ccb49f') - result = asyncio.run(client.solve_captcha(request)) - - for i in required_outs: - self.assertTrue(i in list(result.keys())) - -if __name__ == '__main__': - unittest.main() - \ No newline at end of file diff --git a/test/image_requests_test.py b/test/image_requests_test.py deleted file mode 100644 index 9a6e4f2..0000000 --- a/test/image_requests_test.py +++ /dev/null @@ -1,132 +0,0 @@ -import asyncio -import base64 -import os -import unittest -import urllib - -from capmonstercloudclient.requests import HcaptchaComplexImageTaskRequest, \ - RecaptchaComplexImageTaskRequest, FunCaptchaComplexImageTaskRequest -from capmonstercloudclient import CapMonsterClient, ClientOptions - - -def read_image(image_url: str,): - image_bytes = urllib.request.urlopen(image_url).read() - imageb64 = base64.b64encode(image_bytes).decode('utf-8') - return imageb64 - -recaptcha_metadata = { - "Task": "Click on traffic lights", - "Grid": "3x3", - "TaskDefinition": "/m/015qff" - } -hcaptcha_metadata = { - 'Task': 'Please click each image containing a motorcycle' - } -funcaptcha_metadata = { - 'Task': 'Pick the image that is the correct way up' - } - -hcaptcha_img_urls = ["https://i.postimg.cc/kg71cbRt/image-1.jpg", - "https://i.postimg.cc/6381Zx2j/image.jpg"] -hcaptcha_images = [] -for img_url in hcaptcha_img_urls: - hcaptcha_images.append(read_image(img_url)) - - -recaptcha_img_urls = ["https://i.postimg.cc/yYjg75Kv/payloadtraffic.jpg"] -recaptcha_images = [] -for img_url in recaptcha_img_urls: - recaptcha_images.append(read_image(img_url)) - - -funcaptcha_img_urls = ["https://i.postimg.cc/s2ZDrHXy/fc1.jpg"] -funcaptcha_images = [] -for img_url in funcaptcha_img_urls: - funcaptcha_images.append(read_image(img_url)) - -api_key = os.getenv('API_KEY') -userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36." - -class TestRequests(unittest.IsolatedAsyncioTestCase): - - def testSolvingHcaptchaWithUrls(self): - fields = ['answer', 'metadata'] - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options=options) - request = HcaptchaComplexImageTaskRequest(metadata=hcaptcha_metadata, - imagesUrls=hcaptcha_img_urls, - # userAgent=userAgent, - ) - result = asyncio.run(client.solve_captcha(request)) - keys = list(result.keys()) - for f in fields: - self.assertTrue(f in keys) - self.assertTrue(all([isinstance(x, bool) for x in result['answer']])) - - - def testSolvingHcaptchaWithBase64(self): - fields = ['answer', 'metadata'] - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options=options) - request = HcaptchaComplexImageTaskRequest(metadata=hcaptcha_metadata, - imagesBase64=hcaptcha_images) - result = asyncio.run(client.solve_captcha(request)) - keys = list(result.keys()) - for f in fields: - self.assertTrue(f in keys) - self.assertTrue(all([isinstance(x, bool) for x in result['answer']])) - - def testSolvingFuncaptchaWithBase64(self): - fields = ['answer', 'metadata'] - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options=options) - request = FunCaptchaComplexImageTaskRequest(metadata=funcaptcha_metadata, - imagesBase64=funcaptcha_images) - result = asyncio.run(client.solve_captcha(request)) - keys = list(result.keys()) - for f in fields: - self.assertTrue(f in keys) - self.assertTrue(all([isinstance(x, bool) for x in result['answer']])) - - - def testSolvingFuncaptchaWithUrls(self): - fields = ['answer', 'metadata'] - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options=options) - request = FunCaptchaComplexImageTaskRequest(metadata=funcaptcha_metadata, - imagesUrls=funcaptcha_img_urls) - result = asyncio.run(client.solve_captcha(request)) - keys = list(result.keys()) - for f in fields: - self.assertTrue(f in keys) - self.assertTrue(all([isinstance(x, bool) for x in result['answer']])) - - def testSolvingRecaptchaWithUrls(self): - fields = ['answer', 'metadata'] - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options=options) - request = RecaptchaComplexImageTaskRequest(metadata=recaptcha_metadata, - imagesUrls=recaptcha_img_urls, - # userAgent=userAgent, - ) - result = asyncio.run(client.solve_captcha(request)) - keys = list(result.keys()) - for f in fields: - self.assertTrue(f in keys) - self.assertTrue(all([isinstance(x, bool) for x in result['answer']])) - - def testSolvingRecaptchaWithBase64(self): - fields = ['answer', 'metadata'] - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options=options) - request = RecaptchaComplexImageTaskRequest(metadata=recaptcha_metadata, - imagesBase64=recaptcha_images) - result = asyncio.run(client.solve_captcha(request)) - keys = list(result.keys()) - for f in fields: - self.assertTrue(f in keys) - self.assertTrue(all([isinstance(x, bool) for x in result['answer']])) - - -if __name__ == '__main__': - unittest.main() \ No newline at end of file diff --git a/test/imperva_request_test.py b/test/imperva_request_test.py index 5010fb0..16ac86b 100644 --- a/test/imperva_request_test.py +++ b/test/imperva_request_test.py @@ -6,50 +6,65 @@ class ImpervaRequestTest(unittest.TestCase): - - websiteUrlExample = 'site.com' - userAgentExample = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36' - incapsulaScriptUrlExample = 'dmFyIF8weGQ2ZmU9Wydce..eDUzXHg2YVx4NGYnKV09XzB4Mjk3MTIxO319KCkpOw==' - incapsulaCookieExample = 'l/LsGnrvyB9lNhXI8borDKa2IGcAAAAAX0qAEHheCWuNDquzwb44cw=' + websiteUrlExample = "site.com" + userAgentExample = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" + incapsulaScriptUrlExample = ( + "dmFyIF8weGQ2ZmU9Wydce..eDUzXHg2YVx4NGYnKV09XzB4Mjk3MTIxO319KCkpOw==" + ) + incapsulaCookieExample = "l/LsGnrvyB9lNhXI8borDKa2IGcAAAAAX0qAEHheCWuNDquzwb44cw=" reese84UrlEndpointExample = "Built-with-the-For-hopence-Hurleysurfecting-the-" - def test_imperva(self, - ): - required_fields = ['type', - 'websiteURL', - 'metadata'] - metadata_required_fields = ['incapsulaScriptUrl', 'incapsulaCookie'] - metadata_example = {"incapsulaScriptUrl": self.incapsulaScriptUrlExample,"incapsulaCookie": self.incapsulaCookieExample} - request = ImpervaCustomTaskRequest(websiteUrl=self.websiteUrlExample, metadata=metadata_example) + def test_imperva( + self, + ): + required_fields = ["type", "websiteURL", "metadata"] + metadata_required_fields = ["incapsulaScriptUrl", "incapsulaCookie"] + metadata_example = { + "incapsulaScriptUrl": self.incapsulaScriptUrlExample, + "incapsulaCookie": self.incapsulaCookieExample, + } + request = ImpervaCustomTaskRequest( + websiteUrl=self.websiteUrlExample, metadata=metadata_example + ) task_dictionary = request.getTaskDict() for f in required_fields: - self.assertTrue(f in list(task_dictionary.keys()), - msg=f'Required captcha input key "{f}" does not include to request.') + self.assertTrue( + f in list(task_dictionary.keys()), + msg=f'Required captcha input key "{f}" does not include to request.', + ) for f in metadata_required_fields: - self.assertTrue(f in list(task_dictionary['metadata'].keys()), - msg=f'Required captcha input key "{f}" does not include to request.') - - def test_imperva_metadata(self,): + self.assertTrue( + f in list(task_dictionary["metadata"].keys()), + msg=f'Required captcha input key "{f}" does not include to request.', + ) + + def test_imperva_metadata( + self, + ): base_kwargs = {"websiteUrl": self.websiteUrlExample, "metadata": {}} self.assertRaises(TypeError, ImpervaCustomTaskRequest, **base_kwargs) - base_kwargs['metadata']['incapsulaScriptUrl'] = self.incapsulaScriptUrlExample + base_kwargs["metadata"]["incapsulaScriptUrl"] = self.incapsulaScriptUrlExample self.assertRaises(TypeError, ImpervaCustomTaskRequest, **base_kwargs) - base_kwargs['metadata']['incapsulaCookie'] = self.incapsulaCookieExample + base_kwargs["metadata"]["incapsulaCookie"] = self.incapsulaCookieExample ImpervaCustomTaskRequest(**base_kwargs) - base_kwargs['metadata']['reese84UrlEndpoint'] = self.reese84UrlEndpointExample + base_kwargs["metadata"]["reese84UrlEndpoint"] = self.reese84UrlEndpointExample ImpervaCustomTaskRequest(**base_kwargs) - def test_imperva_missing(self,): - required_fields = ['type', - 'websiteURL', - 'metadata'] + def test_imperva_missing( + self, + ): + required_fields = ["type", "websiteURL", "metadata"] base_kwargs = {} - metadata_example = {"incapsulaScriptUrl": self.incapsulaScriptUrlExample,"incapsulaCookie": self.incapsulaCookieExample} + metadata_example = { + "incapsulaScriptUrl": self.incapsulaScriptUrlExample, + "incapsulaCookie": self.incapsulaCookieExample, + } self.assertRaises(ValidationError, ImpervaCustomTaskRequest, **base_kwargs) - base_kwargs.update({'websiteUrl': self.websiteUrlExample}) + base_kwargs.update({"websiteUrl": self.websiteUrlExample}) self.assertRaises(ValidationError, ImpervaCustomTaskRequest, **base_kwargs) - base_kwargs.update({'metadata': metadata_example}) + base_kwargs.update({"metadata": metadata_example}) ImpervaCustomTaskRequest(**base_kwargs) -if __name__ == '__main__': - unittest.main() \ No newline at end of file + +if __name__ == "__main__": + unittest.main() diff --git a/test/mtcaptcha_test.py b/test/mtcaptcha_test.py new file mode 100644 index 0000000..ea9ad23 --- /dev/null +++ b/test/mtcaptcha_test.py @@ -0,0 +1,56 @@ +import unittest + +from pydantic.error_wrappers import ValidationError +from capmonstercloudclient.requests import MTCaptchaRequest + + +class MTCaptchaRequestTest(unittest.TestCase): + websiteUrlExample = "https://example.com" + websiteKeyExample = "189123456" + userAgentExample = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" + + def testCaptchaInputTypes(self): + with self.assertRaises(ValidationError): + request = MTCaptchaRequest() + with self.assertRaises(ValidationError): + request = MTCaptchaRequest(websiteUrl=self.websiteUrlExample) + with self.assertRaises(ValidationError): + request = MTCaptchaRequest(websiteKey=self.websiteKeyExample) + + request = MTCaptchaRequest( + websiteKey=self.websiteKeyExample, websiteUrl=self.websiteUrlExample + ) + request = MTCaptchaRequest( + websiteKey=self.websiteKeyExample, + websiteUrl=self.websiteUrlExample, + isInvisible=True, + ) + request = MTCaptchaRequest( + websiteKey=self.websiteKeyExample, + websiteUrl=self.websiteUrlExample, + pageAction="login", + ) + request = MTCaptchaRequest( + websiteKey=self.websiteKeyExample, + websiteUrl=self.websiteUrlExample, + userAgent=self.userAgentExample, + ) + + def testAllRequiredFieldsFilling(self): + required_fields = ["type", "websiteURL", "websiteKey"] + request = MTCaptchaRequest( + websiteUrl=self.websiteUrlExample, + websiteKey=self.websiteKeyExample, + ) + request_dict = request.getTaskDict() + for i in required_fields: + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["type"], "MTCaptchaTask") + + +if __name__ == "__main__": + unittest.main() diff --git a/test/proxy_fields_test.py b/test/proxy_fields_test.py index 9dbfbaa..facc8d0 100644 --- a/test/proxy_fields_test.py +++ b/test/proxy_fields_test.py @@ -1,30 +1,32 @@ import unittest -from capmonstercloudclient.requests.proxy_info import ProxyInfo - +from capmonstercloudclient.requests import ProxyInfo + + +FIELDS = ["proxyType", "proxyAddress", "proxyPort", "proxyLogin", "proxyPassword"] -FIELDS = ['proxyType', 'proxyAddress', 'proxyPort', 'proxyLogin', 'proxyPassword'] class ProxyFieldsTest(unittest.TestCase): - proxyPort: int = 8000 - proxyType: str = 'https' - proxyAddress: str = 'proxyAddress' - proxyLogin: str = 'proxyLogin' - proxyPassword: str = 'proxyPassword' - + proxyType: str = "https" + proxyAddress: str = "proxyAddress" + proxyLogin: str = "proxyLogin" + proxyPassword: str = "proxyPassword" + def testFields(self): - p = ProxyInfo(proxyType=ProxyFieldsTest.proxyType, - proxyAddress=ProxyFieldsTest.proxyAddress, - proxyPort=ProxyFieldsTest.proxyPort, - proxyLogin=ProxyFieldsTest.proxyLogin, - proxyPassword=ProxyFieldsTest.proxyPassword) + p = ProxyInfo( + proxyType=ProxyFieldsTest.proxyType, + proxyAddress=ProxyFieldsTest.proxyAddress, + proxyPort=ProxyFieldsTest.proxyPort, + proxyLogin=ProxyFieldsTest.proxyLogin, + proxyPassword=ProxyFieldsTest.proxyPassword, + ) d = p.model_dump() for field in FIELDS: self.assertTrue( - field in d, - msg=f'Expected that "{field}" will be in {list(d.keys())}') + field in d, msg=f'Expected that "{field}" will be in {list(d.keys())}' + ) + - -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/test/recaptcha_image_test.py b/test/recaptcha_image_test.py index b3ecec8..05b772a 100644 --- a/test/recaptcha_image_test.py +++ b/test/recaptcha_image_test.py @@ -2,107 +2,147 @@ from pydantic.error_wrappers import ValidationError from capmonstercloudclient.requests import RecaptchaComplexImageTaskRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError +from capmonstercloudclient.exceptions import ( + NumbersImagesErrors, + TaskNotDefinedError, + ZeroImagesErrors, + UserAgentNotDefinedError, +) + class RecaptchaImageRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=middle' - imageUrlsExamples = ['https://i.postimg.cc/yYjg75Kv/payloadtraffic.jpg'] - metadataExample = {'Task': 'Click on traffic lights', - 'Grid': '3x3', - 'TaskDefinition': '/m/015qff',} - + websiteUrlExample = ( + "https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=middle" + ) + imageUrlsExamples = ["https://i.postimg.cc/yYjg75Kv/payloadtraffic.jpg"] + metadataExample = { + "Task": "Click on traffic lights", + "Grid": "3x3", + "TaskDefinition": "/m/015qff", + } + def testImagesTypes(self): - with self.assertRaises(ValidationError): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesBase64='[]') - + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesBase64="[]", + ) + with self.assertRaises(ValidationError): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls='[]') - + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls="[]", + ) + def testImagesFilling(self): - - with self.assertRaises(ZeroImagesErrors, - msg='Empty array imagesUrls must be cause ZeroImagesErrors'): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=[], - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - - with self.assertRaises(ZeroImagesErrors, - msg='Empty array imagesBase64 must be cause ZeroImagesErrors'): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesBase64=[]) - - with self.assertRaises(ZeroImagesErrors, - msg='Both empty arrays imagesBase64 and imagesUrls must be cause ZeroImagesErrors'): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample) + with self.assertRaises( + ZeroImagesErrors, + msg="Empty array imagesUrls must be cause ZeroImagesErrors", + ): + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=[], + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + with self.assertRaises( + ZeroImagesErrors, + msg="Empty array imagesBase64 must be cause ZeroImagesErrors", + ): + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesBase64=[], + ) + + with self.assertRaises( + ZeroImagesErrors, + msg="Both empty arrays imagesBase64 and imagesUrls must be cause ZeroImagesErrors", + ): + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + ) request.getTaskDict() - + def testNumbersImages(self): - - with self.assertRaises(NumbersImagesErrors, - msg='Empty array must be cause ZeroImagesErrors'): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples*2, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - - - with self.assertRaises(NumbersImagesErrors, - msg='Empty array must be cause ZeroImagesErrors'): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesBase64=['base64image']*2, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - + with self.assertRaises( + NumbersImagesErrors, msg="Empty array must be cause ZeroImagesErrors" + ): + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples * 2, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + with self.assertRaises( + NumbersImagesErrors, msg="Empty array must be cause ZeroImagesErrors" + ): + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesBase64=["base64image"] * 2, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + def testAllRequiredFieldsFilling(self): - required_fields = ['class', 'type', 'websiteUrl', 'metadata', 'userAgent'] - metadata_fields = ['Task', 'TaskDefinition', 'Grid'] - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") + required_fields = ["class", "type", "websiteUrl", "metadata", "userAgent"] + metadata_fields = ["Task", "TaskDefinition", "Grid"] + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - - metadata_dict = request_dict['metadata'] + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + metadata_dict = request_dict["metadata"] for i in metadata_fields: - self.assertTrue(i in list(metadata_dict.keys()), - msg=f'Required field {i} not in {request_dict}') - - self.assertEqual(request_dict['class'], 'recaptcha') - self.assertEqual(request_dict['type'], 'ComplexImageTask') - + self.assertTrue( + i in list(metadata_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["class"], "recaptcha") + self.assertEqual(request_dict["type"], "ComplexImageTask") + def testTaskDefined(self): - with self.assertRaises(TaskNotDefinedError, - msg='Expect that empty "Task" field will be cause TaskNotDefinedError'): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata={}, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples) - + with self.assertRaises( + TaskNotDefinedError, + msg='Expect that empty "Task" field will be cause TaskNotDefinedError', + ): + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata={}, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + ) + with self.assertRaises(TaskNotDefinedError): - request = RecaptchaComplexImageTaskRequest(websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, - metadata={'dsfsdf': 'sdfsdf'}, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, - userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.") - - @unittest.skip('Doesnt work right now') + request = RecaptchaComplexImageTaskRequest( + websiteUrl=RecaptchaImageRequestTest.websiteUrlExample, + metadata={"dsfsdf": "sdfsdf"}, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36.", + ) + + @unittest.skip("Doesnt work right now") def testUserAgentWithUrl(self): with self.assertRaises(UserAgentNotDefinedError): - request = RecaptchaComplexImageTaskRequest(metadata=RecaptchaImageRequestTest.metadataExample, - imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples) + request = RecaptchaComplexImageTaskRequest( + metadata=RecaptchaImageRequestTest.metadataExample, + imagesUrls=RecaptchaImageRequestTest.imageUrlsExamples, + ) request.getTaskDict() - -if __name__ == '__main__': - unittest.main() \ No newline at end of file + +if __name__ == "__main__": + unittest.main() diff --git a/test/requests_generation_test.py b/test/requests_generation_test.py index 74849d1..3a7eb55 100644 --- a/test/requests_generation_test.py +++ b/test/requests_generation_test.py @@ -3,198 +3,345 @@ from capmonstercloudclient import requests -PROXY_LIST = ['proxyType', 'proxyAddress', 'proxyPort', 'proxyLogin', 'proxyPassword'] +PROXY_LIST = ["proxyType", "proxyAddress", "proxyPort", "proxyLogin", "proxyPassword"] -class RequestGenerationTests(unittest.TestCase): +class RequestGenerationTests(unittest.TestCase): def test_rcv2(self): - - default_keys = ['type', - 'websiteURL', - 'websiteKey', - 'recaptchaDataSValue', - 'userAgent', - 'cookies'] - rc2_no_proxy_type = 'NoCaptchaTask' - request = requests.RecaptchaV2Request(websiteUrl='some_url', - websiteKey='sime_key', - dataSValue='sdfa', - userAgent='fasdf', - cookies='asdfsdf') + default_keys = [ + "type", + "websiteURL", + "websiteKey", + "recaptchaDataSValue", + "userAgent", + "cookies", + ] + rc2_no_proxy_type = "NoCaptchaTask" + request = requests.RecaptchaV2Request( + websiteUrl="some_url", + websiteKey="sime_key", + dataSValue="sdfa", + userAgent="fasdf", + cookies="asdfsdf", + ) task = request.getTaskDict() for key in default_keys: - self.assertIsNotNone(task.get(key), msg=f'Missing {key} for ReCaptchaV2 request.') - self.assertTrue(rc2_no_proxy_type==task.get('type'), - msg=f'Task type of ReCaptchaV2 not equal to {rc2_no_proxy_type}') + self.assertIsNotNone( + task.get(key), msg=f"Missing {key} for ReCaptchaV2 request." + ) + self.assertTrue( + rc2_no_proxy_type == task.get("type"), + msg=f"Task type of ReCaptchaV2 not equal to {rc2_no_proxy_type}", + ) - rc2_proxy_type = 'NoCaptchaTask' + rc2_proxy_type = "NoCaptchaTask" default_proxy_keys = default_keys + PROXY_LIST + proxy = requests.ProxyInfo( + proxyType="http", + proxyAddress="address", + proxyPort=8001, + proxyLogin="login", + proxyPassword="password", + ) proxy_request = requests.RecaptchaV2Request( - websiteUrl='some_url', websiteKey='some_key', - dataSValue='data s value', userAgent='user agent', - cookies='cookies', proxyType='http', proxyAddress='address', - proxyPort=8001, proxyLogin='login', proxyPassword='password') + websiteUrl="some_url", + websiteKey="some_key", + dataSValue="data s value", + userAgent="user agent", + cookies="cookies", + proxy=proxy, + ) proxy_task = proxy_request.getTaskDict() for key in default_proxy_keys: - self.assertIsNotNone(proxy_task.get(key), msg=f'Missing {key} for ReCaptchaV2 request.') - self.assertTrue(rc2_proxy_type==proxy_task.get('type'), - msg=f'Task type of ReCaptchaV2 not equal to {rc2_proxy_type}') - + self.assertIsNotNone( + proxy_task.get(key), msg=f"Missing {key} for ReCaptchaV2 request." + ) + self.assertTrue( + rc2_proxy_type == proxy_task.get("type"), + msg=f"Task type of ReCaptchaV2 not equal to {rc2_proxy_type}", + ) + def test_rcv3(self): - default_keys = ['type', 'websiteURL', 'websiteKey', 'minScore', 'pageAction'] - rc3_type = 'RecaptchaV3Task' - request = requests.RecaptchaV3Request(websiteUrl='some_url', - websiteKey='some_key', - min_score=0.2, - pageAction='asdfsfd') + default_keys = ["type", "websiteURL", "websiteKey", "minScore", "pageAction"] + rc3_type = "RecaptchaV3TaskProxyless" + request = requests.RecaptchaV3ProxylessRequest( + websiteUrl="some_url", + websiteKey="some_key", + min_score=0.2, + pageAction="asdfsfd", + ) task = request.getTaskDict() - + for key in default_keys: - self.assertIsNotNone(task.get(key), msg=f'Missing {key} for ReCaptchaV3 request.') - - self.assertEqual(rc3_type, task.get('type'), - msg=f'Task type of ReCaptchaV3 not equal to {rc3_type}') - + self.assertIsNotNone( + task.get(key), msg=f"Missing {key} for ReCaptchaV3 request." + ) + + self.assertEqual( + rc3_type, + task.get("type"), + msg=f"Task type of ReCaptchaV3 not equal to {rc3_type}", + ) + def test_rcv2_enterprise(self): - - rcv2e_type = 'RecaptchaV2EnterpriseTask' - default_keys = ['type', 'websiteURL', 'websiteKey', 'enterprisePayload', 'apiDomain'] - request = requests.RecaptchaV2EnterpriseRequest(websiteUrl='some_url', - websiteKey='some_key', - enterprisePayload='payload', - apiDomain='asdfasdf') + rcv2e_type = "RecaptchaV2EnterpriseTask" + default_keys = [ + "type", + "websiteURL", + "websiteKey", + "enterprisePayload", + "apiDomain", + ] + request = requests.RecaptchaV2EnterpriseRequest( + websiteUrl="some_url", + websiteKey="some_key", + enterprisePayload="payload", + apiDomain="asdfasdf", + ) task = request.getTaskDict() for key in default_keys: - self.assertIsNotNone(task.get(key), msg=f'Missing {key} for RecaptchaV2EnterpriseTask request.') - self.assertEqual(rcv2e_type, task.get('type'), - msg=f'Task type of RecaptchaV2EnterpriseTask not equal to {rcv2e_type}') + self.assertIsNotNone( + task.get(key), + msg=f"Missing {key} for RecaptchaV2EnterpriseTask request.", + ) + self.assertEqual( + rcv2e_type, + task.get("type"), + msg=f"Task type of RecaptchaV2EnterpriseTask not equal to {rcv2e_type}", + ) + proxy = requests.ProxyInfo( + proxyType="http", + proxyAddress="address", + proxyPort=8001, + proxyLogin="login", + proxyPassword="password", + ) proxy_request = requests.RecaptchaV2EnterpriseRequest( - websiteUrl='some_url', websiteKey='some_key', - enterprisePayload='payload', apiDomain='asdfasdf', - proxyType='http', proxyAddress='address', - proxyPort=8001, proxyLogin='login', proxyPassword='password') - + websiteUrl="some_url", + websiteKey="some_key", + enterprisePayload="payload", + apiDomain="asdfasdf", + proxy=proxy, + ) + proxy_keys = default_keys + PROXY_LIST - proxy_type = 'RecaptchaV2EnterpriseTask' + proxy_type = "RecaptchaV2EnterpriseTask" proxy_task = proxy_request.getTaskDict() for key in proxy_keys: - self.assertIsNotNone(proxy_task.get(key), - msg=f'Missing {key} for RecaptchaV2EnterpriseTask request.') - self.assertEqual(proxy_type, proxy_task.get('type'), - msg=f'Task type of RecaptchaV2EnterpriseTask not equal to {proxy_type}') - + self.assertIsNotNone( + proxy_task.get(key), + msg=f"Missing {key} for RecaptchaV2EnterpriseTask request.", + ) + self.assertEqual( + proxy_type, + proxy_task.get("type"), + msg=f"Task type of RecaptchaV2EnterpriseTask not equal to {proxy_type}", + ) + def test_fc(self): - noproxy_type = 'FunCaptchaTask' - default_keys = ['type', 'websiteURL', 'funcaptchaApiJSSubdomain', 'websitePublicKey', 'data'] - request = requests.FuncaptchaRequest(websiteUrl='some_url', - websitePublicKey='some_key', - funcaptchaApiJSSubdomain='domain', - data='asdfasdf') + noproxy_type = "FunCaptchaTask" + default_keys = [ + "type", + "websiteURL", + "funcaptchaApiJSSubdomain", + "websitePublicKey", + "data", + ] + request = requests.FuncaptchaRequest( + websiteUrl="some_url", + websitePublicKey="some_key", + funcaptchaApiJSSubdomain="domain", + data="asdfasdf", + ) task = request.getTaskDict() for key in default_keys: - self.assertIsNotNone(task.get(key), - msg=f'Missing {key} for FunCaptchaTask request.') - self.assertEqual(noproxy_type, task.get('type'), - msg=f'Task type of FunCaptchaTask not equal to {noproxy_type}') - - proxy_type = 'FunCaptchaTask' + self.assertIsNotNone( + task.get(key), msg=f"Missing {key} for FunCaptchaTask request." + ) + self.assertEqual( + noproxy_type, + task.get("type"), + msg=f"Task type of FunCaptchaTask not equal to {noproxy_type}", + ) + + proxy_type = "FunCaptchaTask" proxy_keys = default_keys + PROXY_LIST + proxy = requests.ProxyInfo( + proxyType="http", + proxyAddress="address", + proxyPort=8001, + proxyLogin="login", + proxyPassword="password", + ) proxy_request = requests.FuncaptchaRequest( - websiteUrl='some_url', websitePublicKey='some_key', - funcaptchaApiJSSubdomain='domain', data='asdfasdf', - proxyType='http', proxyAddress='address', - proxyPort=8001, proxyLogin='login', proxyPassword='password') - + websiteUrl="some_url", + websitePublicKey="some_key", + funcaptchaApiJSSubdomain="domain", + data="asdfasdf", + proxy=proxy, + ) + proxy_task = proxy_request.getTaskDict() for key in proxy_keys: - self.assertIsNotNone(proxy_task.get(key), - msg=f'Missing {key} for FunCaptchaTask request.') - self.assertEqual(proxy_type, proxy_task.get('type'), - msg=f'Task type of FunCaptchaTask not equal to {noproxy_type}') - + self.assertIsNotNone( + proxy_task.get(key), msg=f"Missing {key} for FunCaptchaTask request." + ) + self.assertEqual( + proxy_type, + proxy_task.get("type"), + msg=f"Task type of FunCaptchaTask not equal to {noproxy_type}", + ) + def test_hc(self): - - noproxy_type = 'HCaptchaTask' - default_keys = ['type', 'websiteURL', 'websiteKey', 'isInvisible', 'data', 'userAgent', 'cookies'] - request = requests.HcaptchaRequest(websiteUrl='some_url', - websiteKey='some_key', - is_invisible=False, - data='data', - user_agent='agent', - cookies='cookies') + noproxy_type = "HCaptchaTask" + default_keys = [ + "type", + "websiteURL", + "websiteKey", + "isInvisible", + "data", + "userAgent", + "cookies", + ] + request = requests.HcaptchaRequest( + websiteUrl="some_url", + websiteKey="some_key", + is_invisible=False, + data="data", + user_agent="agent", + cookies="cookies", + ) task = request.getTaskDict() for key in default_keys: - self.assertIsNotNone(task.get(key), - msg=f'Missing {key} for HCaptchaTask request.') - self.assertEqual(noproxy_type, task.get('type'), - msg=f'Task type of HCaptchaTask not equal to {noproxy_type}') - + self.assertIsNotNone( + task.get(key), msg=f"Missing {key} for HCaptchaTask request." + ) + self.assertEqual( + noproxy_type, + task.get("type"), + msg=f"Task type of HCaptchaTask not equal to {noproxy_type}", + ) + + proxy = requests.ProxyInfo( + proxyType="http", + proxyAddress="address", + proxyPort=8001, + proxyLogin="login", + proxyPassword="password", + ) proxy_request = requests.HcaptchaRequest( - websiteUrl='some_url', websiteKey='some_key', - is_invisible=False, data='data', user_agent='agent', - cookies='cookies', proxyType='http', proxyAddress='address', - proxyPort=8001, proxyLogin='login', proxyPassword='password') + websiteUrl="some_url", + websiteKey="some_key", + is_invisible=False, + data="data", + user_agent="agent", + cookies="cookies", + proxy=proxy, + ) - proxy_type = 'HCaptchaTask' + proxy_type = "HCaptchaTask" proxy_keys = default_keys + PROXY_LIST proxy_task = proxy_request.getTaskDict() for key in proxy_keys: - self.assertIsNotNone(proxy_task.get(key), - msg=f'Missing {key} for HCaptchaTask request.') - self.assertEqual(proxy_type, proxy_task.get('type'), - msg=f'Task type of HCaptchaTask not equal to {proxy_type}') - + self.assertIsNotNone( + proxy_task.get(key), msg=f"Missing {key} for HCaptchaTask request." + ) + self.assertEqual( + proxy_type, + proxy_task.get("type"), + msg=f"Task type of HCaptchaTask not equal to {proxy_type}", + ) def test_image2text(self): - noproxy_type = 'ImageToTextTask' - default_keys = ['type', 'body', 'CapMonsterModule', - 'recognizingThreshold', 'Case', 'numeric', 'math'] - request = requests.ImageToTextRequest(image_bytes=b'123321', - module_name='amazon', - threshold=80, - case=False, - numeric=1, - math=True) + noproxy_type = "ImageToTextTask" + default_keys = [ + "type", + "body", + "CapMonsterModule", + "recognizingThreshold", + "Case", + "numeric", + "math", + ] + request = requests.ImageToTextRequest( + image_bytes=b"123321", + module_name="amazon", + threshold=80, + case=False, + numeric=1, + math=True, + ) task = request.getTaskDict() for key in default_keys: - self.assertIsNotNone(task.get(key), - msg=f'Missing {key} for ImageToTextTask request.') - self.assertEqual(noproxy_type, task.get('type'), - msg=f'Task type of ImageToTextTask not equal to {noproxy_type}') + self.assertIsNotNone( + task.get(key), msg=f"Missing {key} for ImageToTextTask request." + ) + self.assertEqual( + noproxy_type, + task.get("type"), + msg=f"Task type of ImageToTextTask not equal to {noproxy_type}", + ) def test_gt(self): - - noproxy_type = 'GeeTestTask' - default_keys = ['type', 'websiteURL', 'gt', - 'challenge', 'geetestApiServerSubdomain', - 'geetestGetLib', 'userAgent'] - request = requests.GeetestRequest(websiteUrl='some_url', - gt='some_key', - challenge='challenge', - geetestApiServerSubdomain='api.domain', - geetestGetLib='lib', - user_agent='agent') + noproxy_type = "GeeTestTask" + default_keys = [ + "type", + "websiteURL", + "gt", + "challenge", + "geetestApiServerSubdomain", + "geetestGetLib", + "userAgent", + ] + request = requests.GeetestRequest( + websiteUrl="some_url", + gt="some_key", + challenge="challenge", + geetestApiServerSubdomain="api.domain", + geetestGetLib="lib", + user_agent="agent", + ) task = request.getTaskDict() for key in default_keys: - self.assertIsNotNone(task.get(key), - msg=f'Missing {key} for GeeTestTask request.') - self.assertEqual(noproxy_type, task.get('type'), - msg=f'Task type of GeeTestTask not equal to {noproxy_type}') + self.assertIsNotNone( + task.get(key), msg=f"Missing {key} for GeeTestTask request." + ) + self.assertEqual( + noproxy_type, + task.get("type"), + msg=f"Task type of GeeTestTask not equal to {noproxy_type}", + ) + proxy = requests.ProxyInfo( + proxyType="http", + proxyAddress="address", + proxyPort=8001, + proxyLogin="login", + proxyPassword="password", + ) proxy_request = requests.GeetestRequest( - websiteUrl='some_url', gt='some_key', challenge='challenge', - geetestApiServerSubdomain='api.domain', geetestGetLib='lib', - user_agent='agent', proxyType='http', proxyAddress='address', - proxyPort=8001, proxyLogin='login', proxyPassword='password') + websiteUrl="some_url", + gt="some_key", + challenge="challenge", + geetestApiServerSubdomain="api.domain", + geetestGetLib="lib", + user_agent="agent", + proxy=proxy, + ) proxy_task = proxy_request.getTaskDict() - proxy_type = 'GeeTestTask' + proxy_type = "GeeTestTask" proxy_keys = default_keys + PROXY_LIST for key in proxy_keys: - self.assertIsNotNone(proxy_task.get(key), - msg=f'Missing {key} for GeeTestTask request.') - self.assertEqual(proxy_type, proxy_task.get('type'), - msg=f'Task type of GeeTestTask not equal to {proxy_type}') + self.assertIsNotNone( + proxy_task.get(key), msg=f"Missing {key} for GeeTestTask request." + ) + self.assertEqual( + proxy_type, + proxy_task.get("type"), + msg=f"Task type of GeeTestTask not equal to {proxy_type}", + ) + -if __name__ == '__main__': - unittest.main() \ No newline at end of file +if __name__ == "__main__": + unittest.main() diff --git a/test/tendi_response_test.py b/test/tendi_response_test.py deleted file mode 100644 index 7720952..0000000 --- a/test/tendi_response_test.py +++ /dev/null @@ -1,38 +0,0 @@ -import unittest -import asyncio -import os - -from pydantic.error_wrappers import ValidationError -from capmonstercloudclient.requests import TenDiCustomTaskRequest -from capmonstercloudclient import CapMonsterClient, ClientOptions - -def get_all_keys(dictionary): - all_values = [] - def recursive_items(dictionary): - for key, value in dictionary.items(): - if type(value) is dict: - all_values.append(key) - recursive_items(value) - else: - all_values.append(key) - return all_values - return recursive_items(dictionary) - -class TenDiOutsTest(unittest.TestCase): - - def testOuts(self): - required_outs = ['domains', 'fingerprint', 'data', 'ticket', 'randstr'] - api_key = os.getenv('API_KEY') - options = ClientOptions(api_key=api_key) - client = CapMonsterClient(options) - - request = TenDiCustomTaskRequest(websiteUrl='https://www.tencentcloud.com/account/login?s_url=https%3A%2F%2Fconsole.tencentcloud.com%2F', - websiteKey='2009899766') - result = asyncio.run(client.solve_captcha(request)) - for i in required_outs: - self.assertTrue(i in get_all_keys(result)) - - -if __name__ == '__main__': - unittest.main() - \ No newline at end of file diff --git a/test/tendi_test.py b/test/tendi_test.py index 0a90b50..a55dbaf 100644 --- a/test/tendi_test.py +++ b/test/tendi_test.py @@ -2,43 +2,46 @@ from pydantic.error_wrappers import ValidationError from capmonstercloudclient.requests import TenDiCustomTaskRequest -from capmonstercloudclient.exceptions import NumbersImagesErrors, TaskNotDefinedError, ZeroImagesErrors, \ - UserAgentNotDefinedError + class TenDiCustomTaskRequestTest(unittest.TestCase): - - websiteUrlExample = 'https://example.com' - websiteKeyExample = '189123456' - userAgentExample = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36' + websiteUrlExample = "https://example.com" + websiteKeyExample = "189123456" + userAgentExample = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" def testCaptchaInputTypes(self): - with self.assertRaises(ValidationError): - request = TenDiCustomTaskRequest(websiteUrl=TenDiCustomTaskRequestTest.websiteUrlExample) - + request = TenDiCustomTaskRequest( + websiteUrl=TenDiCustomTaskRequestTest.websiteUrlExample + ) + with self.assertRaises(ValidationError): request = TenDiCustomTaskRequest( - websiteKey=TenDiCustomTaskRequestTest.websiteKeyExample, - ) - - - request = TenDiCustomTaskRequest(websiteUrl=TenDiCustomTaskRequestTest.websiteUrlExample, - websiteKey=TenDiCustomTaskRequestTest.websiteKeyExample, - userAgent=TenDiCustomTaskRequestTest.userAgentExample - ) - + websiteKey=TenDiCustomTaskRequestTest.websiteKeyExample, + ) + + request = TenDiCustomTaskRequest( + websiteUrl=TenDiCustomTaskRequestTest.websiteUrlExample, + websiteKey=TenDiCustomTaskRequestTest.websiteKeyExample, + userAgent=TenDiCustomTaskRequestTest.userAgentExample, + ) + def testAllRequiredFieldsFilling(self): - required_fields = ['class', 'type', 'websiteURL', 'websiteKey'] - request = TenDiCustomTaskRequest(websiteUrl=TenDiCustomTaskRequestTest.websiteUrlExample, - websiteKey=TenDiCustomTaskRequestTest.websiteKeyExample) + required_fields = ["class", "type", "websiteURL", "websiteKey"] + request = TenDiCustomTaskRequest( + websiteUrl=TenDiCustomTaskRequestTest.websiteUrlExample, + websiteKey=TenDiCustomTaskRequestTest.websiteKeyExample, + ) request_dict = request.getTaskDict() for i in required_fields: - self.assertTrue(i in list(request_dict.keys()), - msg=f'Required field {i} not in {request_dict}') + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["class"], "TenDI") + self.assertEqual(request_dict["type"], "CustomTask") - self.assertEqual(request_dict['class'], 'TenDI') - self.assertEqual(request_dict['type'], 'CustomTask') - -if __name__ == '__main__': - unittest.main() \ No newline at end of file +if __name__ == "__main__": + unittest.main() diff --git a/test/turnstile_test.py b/test/turnstile_test.py index 7fe8cbe..99fd53d 100644 --- a/test/turnstile_test.py +++ b/test/turnstile_test.py @@ -1,8 +1,9 @@ -import unittest from copy import deepcopy +import unittest from pydantic import ValidationError -from capmonstercloudclient.requests import TurnstileRequest + +from capmonstercloudclient.requests import ProxyInfo, TurnstileRequest class TurnstileResponseTest(unittest.TestCase): @@ -34,8 +35,19 @@ def test_cf_clearance_inputs(self): 'websiteURL', 'websiteKey', 'cloudflareTaskType', - 'htmlPageBase64'] - + 'htmlPageBase64', + 'proxyType', + 'proxyAddress', + 'proxyPort', + 'proxyLogin', + 'proxyPassword'] + proxy = ProxyInfo( + proxyType="http", + proxyAddress="8.8.8.8", + proxyPort=8000, + proxyLogin="proxyLoginHere", + proxyPassword="proxyPasswordHere" + ) request = TurnstileRequest(websiteKey='0x4AAAAAAADnPIDROrmt1Wwj', websiteURL='https://nowsecure.nl', cloudflareTaskType='cf_clearance', @@ -43,6 +55,7 @@ def test_cf_clearance_inputs(self): userAgent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) ' \ 'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.' \ '0.0.0 Safari/537.36', + proxy=proxy ) task_dictionary = request.getTaskDict() for f in required_fields: @@ -70,7 +83,7 @@ def test_token_inputs(self): self.assertTrue(f in list(task_dictionary.keys()), msg=f'Required captcha input key "{f}" does not include to request.') - def test_failed_cf_clearance_cases(self): + def test_failed_token_cases(self): base_kwargs = {'websiteKey': '0x4AAAAAAADnPIDROrmt1Wwj', 'websiteURL': 'https://nowsecure.nl'} @@ -88,7 +101,7 @@ def test_failed_cf_clearance_cases(self): kwargs_1.update({'userAgent': 'userAgent'}) TurnstileRequest(**kwargs_1) - def test_failed_token_cases(self): + def test_failed_cf_clearance_cases(self): base_kwargs = {'websiteKey': '0x4AAAAAAADnPIDROrmt1Wwj', 'websiteURL': 'https://nowsecure.nl'} @@ -100,6 +113,15 @@ def test_failed_token_cases(self): kwargs_2.update({'htmlPageBase64': 'htmlPageBase64Here'}) self.assertRaises(RuntimeError, TurnstileRequest, **kwargs_2) kwargs_2.update({'userAgent': 'userAgent'}) + self.assertRaises(RuntimeError, TurnstileRequest, **kwargs_2) + proxy = ProxyInfo( + proxyType="http", + proxyAddress="8.8.8.8", + proxyPort=8000, + proxyLogin="proxyLoginHere", + proxyPassword="proxyPasswordHere" + ) + kwargs_2.update({'proxy': proxy}) TurnstileRequest(**kwargs_2) if __name__ == '__main__': diff --git a/test/yidun_test.py b/test/yidun_test.py new file mode 100644 index 0000000..371b5f2 --- /dev/null +++ b/test/yidun_test.py @@ -0,0 +1,46 @@ +import unittest + +from pydantic.error_wrappers import ValidationError +from capmonstercloudclient.requests import YidunRequest + + +class YidunRequestTest(unittest.TestCase): + websiteUrlExample = "https://example.com" + websiteKeyExample = "189123456" + userAgentExample = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" + + def testCaptchaInputTypes(self): + with self.assertRaises(ValidationError): + request = YidunRequest() + with self.assertRaises(ValidationError): + request = YidunRequest(websiteUrl=self.websiteUrlExample) + with self.assertRaises(ValidationError): + request = YidunRequest(websiteKey=self.websiteKeyExample) + + request = YidunRequest( + websiteKey=self.websiteKeyExample, websiteUrl=self.websiteUrlExample + ) + request = YidunRequest( + websiteKey=self.websiteKeyExample, + websiteUrl=self.websiteUrlExample, + userAgent=self.userAgentExample, + ) + + def testAllRequiredFieldsFilling(self): + required_fields = ["type", "websiteURL", "websiteKey"] + request = YidunRequest( + websiteUrl=self.websiteUrlExample, + websiteKey=self.websiteKeyExample, + ) + request_dict = request.getTaskDict() + for i in required_fields: + self.assertTrue( + i in list(request_dict.keys()), + msg=f"Required field {i} not in {request_dict}", + ) + + self.assertEqual(request_dict["type"], "YidunTask") + + +if __name__ == "__main__": + unittest.main()