-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathtest_code.jsonl
More file actions
100 lines (100 loc) · 92.3 KB
/
Copy pathtest_code.jsonl
File metadata and controls
100 lines (100 loc) · 92.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_registered_mobile_phone__empty(self) -> None:\n \"\"\"\n Given:\n - a redis key\n - a redis container without mobile phones registered\n When i list registered mobile phones\n Then i get a response with 404 status\n \"\"\"\n random_suffix = str(random.SystemRandom().randint(0, 9))\n subscriber_id = \"subscriber_id_\" + random_suffix\n prom_code = \"prom_code_\" + random_suffix\n ircam_channel_id = 2\n adapter = RedisCaptureAdapter()\n\n self.when_i_simulate_mobile_phones_waiting_for_take_capture_notification(\n adapter=adapter,\n prom_code=prom_code,\n ircam_channel_id=ircam_channel_id,\n subscriber_id=subscriber_id,\n number_of_phones=0,\n )\n\n self.when_i_list_registered_mobile_phone(prom_code=prom_code, ircam_channel_id=ircam_channel_id)\n assert_that(self.last_response.status_code, is_(status.HTTP_404_NOT_FOUND))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_rating(self) -> None:\n \"\"\"\n Given a delivery\n When I rate\n Then 200 OK\n \"\"\"\n self.client = AuthenticatedClient()\n order = self.any_order(user=self.client.user, api_version=API_VERSION)\n delivery = self.any_delivery(order=order, api_version=API_VERSION)\n\n self.when_i_post_delivery_rating(delivery_id=delivery.id, rating=4)\n\n assert_that(self.last_response, http(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_booking__closed(self) -> None:\n \"\"\"\n Given:\n - a booking with a drop off time tomorrow\n - station closed tomorrow\n - a cart\n When i create carte item\n Then I get HTTP 400\"\"\"\n self.client = AuthenticatedClient()\n now = timezone.make_aware(datetime.datetime(2022, 1, 19, 15, 0, 0))\n tomorrow = now + datetime.timedelta(days=1)\n\n booking = self.any_booking()\n booking.dropoff_time = tomorrow\n booking.save()\n\n booking.station.closed_on = [{\"date\": tomorrow.strftime(\"%Y-%m-%d\"), \"reason\": \"\"}]\n booking.station.save()\n\n cart = self.any_cart(user=self.client.user, api_version=API_VERSION)\n\n self.when_i_create_cart_item(\n cart_id=cart.id, item_type=create_cart_item_types.booking, reference=booking.pk, quantity=1\n )\n\n assert_that(self.last_response, http(400))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_credits_to_fleet_prepaid_accounts__not_apply(self) -> None:\n fleet_prepaid_account = self.any_prepaid_account__fleet()\n user = fleet_prepaid_account.owner\n user.is_fleet_owner = False\n user.save()\n\n data = {\n \"action\": \"add_credits_to_fleet_prepaid_accounts\",\n \"_selected_action\": [fleet_prepaid_account.pk],\n \"price_including_vat\": \"80\",\n \"nb_day_for_payment\": \"10\",\n \"price_credits\": \"100\",\n }\n self.last_response = self.client.post(\n reverse(\"kleenapi_admin_site:credits_prepaidaccount_changelist\"), data=data, follow=True\n )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_unpublish_master_scenario_maia_error(self) -> None:\n \"\"\"\n Given a master scenario\n When I unpublish the scenario with maia exception\n Then I get a 502 HTTP response\n \"\"\"\n panel_scenario = self.any_scenario(hss=self.client.hss, state=states.published)\n master_scenario = self.any_master_scenario(hss=self.client.hss, panel_scenario=panel_scenario)\n with mock.patch.object( # noqa: RMS102\n MaiaScenarioDriver, \"deactivate_scenario\", side_effect=MaiaScenarioDriverException\n ):\n self.when_i_unpublish_scenario(hss_pk=self.client.hss.pk, scenario_pk=master_scenario.pk)\n assert_that(self.last_response.status_code, is_(502))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_contracts_related_user_delegation_full_with_delegation_limted(self) -> None:\n \"\"\"\n Given a contract with with user\n Given other contract\n Given a delegation to other contract with limited access\n When I get_contracts_related_user with full\n Then I have one contract\n \"\"\"\n contract_owner = self.any_contract()\n contract_delegation = self.any_honeywell_contract()\n self.any_delegation(contract=contract_delegation, user=contract_owner.user, role=roles.limited, enabled=True)\n contracts = Contract.objects.get_contracts_related_user(user=contract_owner.user, role_required=roles.full)\n assert_that(contracts, contains_exactly(contract_owner))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_loader_twip__corporation(self) -> None:\n autowash = load(\"autowash_twip_corporation.json\")\n loader = AutowashLoader()\n station = loader.as_instance(autowash)[0]\n assert_that(station.operator.seller_type, is_(seller_types.tmf))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_transactions_payload(self) -> None:\n \"\"\"\n Given any hss\n Given a user name that contains space\n When I add a code and create transaction\n Then the transaction payload is good\n \"\"\"\n hss = self.any_hss(remote_proxy=remote_proxies.honeywell)\n code = self.any_honeywell_code()\n serializer = DeleteCodeSerializer(\n data={\n \"index\": f\"1_{code.index}\",\n },\n context={\"hss\": hss},\n )\n serializer.is_valid(raise_exception=True)\n transaction = serializer.make_transaction()\n assert_that(\n transaction.payload,\n has_entries(\n {\n \"Prom\": hss.prom_code,\n \"Index\": code.index,\n }\n ),\n )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_hss_group__daily_to_daily(self) -> None:\n \"\"\"\n Given : A logged in User with email, an HSS with group == 'daily'\n When : I update group of this HSS to 'daily'\n Then : status code of the response is 201\n HSS in the response body have entry group == 'daily'\n HSS in the database have entry group == 'daily'\n \"\"\"\n self.when_i_update_hss_group(self.client.hss, data={\"scenario_mode\": groups.daily})\n assert_that(self.last_response.status_code, is_(200))\n data = self.last_response.json()\n assert_that(data, has_entry(\"fields\", is_not(empty())))\n assert_that(data[\"fields\"], has_entry(\"scenario_mode\", is_(groups.daily)))\n self.client.hss.refresh_from_db()\n assert_that(self.client.hss.scenario_mode, is_(groups.daily))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_shipping_type__single_value(self) -> None:\n \"\"\"\n Given\n request_infos form data\n global conf with one value\n When I validate\n Then request_infos is valid, field is hidden\n \"\"\"\n conf = GlobalConfiguration.objects.get(definition__name=\"request.shipping_type\")\n self.any_global_value(conf)\n request = self.any_request(state=\"draft\")\n request_infos_data = self.any_request_infos_form_data(request=request)\n request_infos_form = make_request_informations_form(\n instance=request, read_only=False, action=form_actions.submit\n )(instance=request, data=request_infos_data)\n request_infos_form.is_valid()\n assert_that(request_infos_form.fields[\"shipping_type\"].required, is_(False))\n assert_that(request_infos_form.fields[\"shipping_type\"].widget, is_(Select))\n assert_that(request_infos_form.is_valid(), is_(True))\n assert_that(request_infos_form.cleaned_data[\"shipping_type\"], empty())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_performance__list(self) -> None:\n \"\"\"\n Given an order\n When I retrieve order\n Then the reponse is 200, query number is acceptable\n \"\"\"\n\n self.client = AuthenticatedClient(mangopay_card=mangopay_cards.normal)\n num_orders = 2\n\n for n in range(1, num_orders):\n deal = self.any_deal()\n cart = self.any_cart(user=self.client.user, state=cart_states.empty)\n cart.add_item(deal=deal)\n self.any_order(\n user=self.client.user,\n payment_method=payment_methods.mangopay,\n cart=cart,\n api_version=self.API_VERSION,\n )\n\n with assertNumLessEqualQueries(self, num_orders + 6):\n start_time = time.monotonic()\n self.when_i_list_order()\n end_time = time.monotonic()\n assert_that(end_time - start_time, is_(less_than(1)))\n assert_that(self.last_response.status_code, is_(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_complete_checkout_adapter(self) -> None:\n checkout = self.any_checkout()\n payment = PaymentMethodProvider()\n with self.assertRaises(NotImplementedError) as e:\n assert_that(payment.complete_checkout(checkout), is_(e))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_keypads_driver_not_implemented(self) -> None:\n hss = self.any_hss()\n driver = HssDriver(hss)\n with self.assertRaises(NotImplementedError):\n driver.keypads\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_start_processing__another_user(self) -> None:\n \"\"\"\n Given\n a user authenticated\n a delivery in ready state from another user\n When I post start processing action\n Then 404 not found\n \"\"\"\n self.client = AuthenticatedClient()\n delivery = self.any_delivery(api_version=API_VERSION)\n\n self.when_i_post_delivery_action(delivery_id=delivery.id, action=delivery_actions.start_processing)\n\n assert_that(self.last_response, http(404))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__pickup_city__no_steps(self) -> None:\n \"\"\"\n Given a request without request\n When I use RequestFormatter with 'pickup_city' field to export\n Then it return a dict that contain request pickup city as empty string\n \"\"\"\n request = self.any_request()\n request.steps.all().delete()\n request.refresh_from_db()\n request_csv = RequestFormatter().to_csv(request, fields=[\"pickup_city\"])\n assert_that(request_csv[0], is_(\"\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_rated_android(self) -> None:\n \"\"\"\n Given a registered user that has rated the android app or has chosen to never rate it\n Then return False\n \"\"\"\n user = self.any_user()\n app_rating = self.any_app_rating(user, android_state=app_rating_state.rated)\n\n spec = UserFeedbackAllowsShowRatingScreenSpecification(app_rating_platform.android)\n self.assertEqual(spec.is_satisfied_by(user), False)\n\n app_rating.android_state = app_rating_state.never\n app_rating.save()\n\n spec = UserFeedbackAllowsShowRatingScreenSpecification(app_rating_platform.android)\n self.assertEqual(spec.is_satisfied_by(user), False)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__merchandises(self) -> None:\n \"\"\"\n Given any request packaging units mode\n When I use RequestFormatter with 'merchandises' field to export\n Then it return a dict that contain request merchandises\n \"\"\"\n request = self.any_request(transport_service=transport_services.packaging_units)\n packaging_unit = request.packaging_units.first()\n assert isinstance(packaging_unit, PackagingUnit)\n packaging_unit.full_clean()\n packaging_unit.save()\n request_csv = RequestFormatter().to_csv(request, fields=[\"merchandises\"])\n assert_that(request_csv[0], is_(packaging_unit.description))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_resynchro_task_for_contract__bad_contract_number(self) -> None:\n hss = self.any_hss()\n self.any_resynchro_task(hss=hss, source=resynchro_task_sources.private_api)\n url = reverse(\"private:v34:scenarios:resynchrotask-list\")\n response = self.client.get(url, data={\"contract_number\": \"xxx\"})\n assert_that(response.status_code, is_(400), response.content)\n assert_that(response.json(), has_key(\"contract_number\"), response.content)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_offered_credits_pack(self) -> None:\n \"\"\"\n Given any promocode from promotional campaign\n When I use it\n Then order has promocode_type = offered_credits_pack\n \"\"\"\n\n credits_pack = self.any_credits_pack(credits=100)\n self.any_credits_pack_scheduler(\n credits_pack=credits_pack, schedule_credits=150, state=cp_scheduler_states.in_progress\n )\n\n promocode = self._any_promo_code_v2_offered_credits_pack(credits_pack=credits_pack)\n user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n cart = self.any_cart(user=user, state=cart_states.empty)\n cart.update(promocode=promocode)\n\n order = self.any_order(user=user, payment_method=payment_methods.mangopay, cart=cart)\n assert_that(order.promocode_type, is_(\"offered_credits_pack\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_login_anonymous__with_same_nonce(self) -> None:\n cache.delete(\"nonce.used.same_nonce\")\n self.any_default_promocode()\n consumer = self.any_consumer()\n self.client = SignedKleenClient(consumer=consumer, nonce=\"same_nonce\")\n\n self.when_i_login_anonymously(api_key=self.client.consumer.key)\n assert_that(self.last_response, http(200))\n\n self.when_i_login_anonymously(api_key=self.client.consumer.key)\n assert_that(self.last_response, http(403))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list__is_frauder_by_phone_validation(self) -> None:\n self.client = AuthenticatedClient()\n self.client.user.is_frauder = True\n self.client.user.frauder_reason = frauder_reasons.phone_validation_fail\n self.client.user.last_frauder_update = timezone.now()\n self.client.user.save()\n self.when_i_list_order()\n\n assert_that(self.last_response.status_code, is_(403))\n assert_that(\n self.last_response.json(),\n has_entry(\"detail\", starts_with(\"Par mesure de sécurité, votre compte a été suspendu pendant 24h.\")),\n )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_delegations_role_full(self) -> None:\n \"\"\"\n Given a hss with a delegation with full role\n When I list captures\n Then I get 200\n \"\"\"\n hss = self.client.hss\n self.client = HoneywellAPIClient()\n DelegationMixin().any_delegation(\n contract=hss.site.contract, enabled=True, role=roles.full, user=self.client.user\n )\n self.when_i_list_delegations(hss_pk=hss.pk)\n assert_that(self.last_response.status_code, is_(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_admin(self) -> None:\n\n with assertNumLessEqualQueries(self, 10):\n self.last_response = self.client.get(\n reverse(\n f\"kleenapi_admin_site:{Token._meta.app_label}_{Token._meta.model_name}_changelist\",\n )\n )\n assert_that(self.last_response.status_code, is_(200))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_leave(self) -> None:\n state_scenarios = [\n {\"actual\": request_states.initial, \"expected\": request_states.dropped},\n ]\n for scenario in state_scenarios:\n with self.subTest(scenario=scenario):\n request = self.any_framed_request(state=scenario[\"actual\"], creator=self.client.user)\n RequestActionPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk).form.leave()\n request.refresh_from_db()\n assert_that(request.state, is_(scenario[\"expected\"]))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenarios_maia(self) -> None:\n \"\"\"\n Given a client with contract supporting 'connected home'\n Given a scenario Maia\n When I list scenario\n Then 200\n Then I have 1 scenario with device pk in the action\n \"\"\"\n self.client.hss.site.contract.capabilities.append(ContractCapabilities.connected_home.value)\n self.client.hss.site.contract.save()\n self.any_maia_scenario(hss=self.client.hss)\n device = self.any_local_device(type=DeviceType.heater)\n last_response = self.when_i_list_scenarios()\n assert_that(last_response.status_code, is_(200))\n data = last_response.json()\n assert_that(data, has_length(1))\n assert_that(\n data[0],\n has_entry(\n \"fields\",\n has_entry(\n \"actions\",\n contains(\n has_entry(\n \"data\",\n has_entry(\"device_pk\", is_(str(device.pk))),\n )\n ),\n ),\n ),\n )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_token_with_url_query(self) -> None:\n self._request_token(METHOD_URL_QUERY)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_add_needed_migration__already_present(self) -> None:\n hss = self.client.hss\n self.any_migration(hss=hss, type=migration_types.bec4)\n\n self.when_i_add_needed_migration(hss=hss, migration_type=migration_types.bec4)\n\n assert_that(self.last_response.status_code, is_(status.HTTP_200_OK))\n assert_that(migration_types.bec4, is_in(hss.required_migrations))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve_pdf__not_logged(self) -> None:\n self.user = self.any_user()\n pdf_url = \"userbill/2024/11/11/MP.pdf\"\n order = self.any_order(user=self.any_user(), status=order_states.success)\n order.bill_user.name = pdf_url\n order.save()\n self.when_i_retrieve_s3_file(pdf_path=pdf_url)\n assert_that(self.last_response.status_code, is_(403))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_policies_card(self) -> None:\n \"\"\"\n Given a policy\n When I list policys card\n Then PolicyRepository is called 1 time\n \"\"\"\n self.client = AuthenticatedClient()\n self.any_policy()\n\n with mock.patch(\"kleen.policy.repositories.policy.PolicyRepository.get_all\") as m: # noqa: RMS102\n self.when_i_list_policies_card()\n\n assert_that(m.call_count, is_(1))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_send__station_has_another_best_deal(self) -> None:\n \"\"\"\n Given :\n - an order sold there is more than 60 days\n - a user without frequency\n - a notifier in idle state\n When refreshing notifier\n Then notifier:\n - is in idle state\n - notification time is not none\n - last order time is same as order\n \"\"\"\n self.any_seller()\n user = self.given_user_registered_with_card(\n card_number=MangoPayFixture.TEST_car_number_without_3DS,\n disable_secure_mode=True,\n preferences_frequency=User.FREQUENCY_LONG_TIME,\n with_push_token=True,\n )\n\n order = self.any_order_sold()\n reminder = user.occasional_buyer_notifier_set.get(zone_context=order.zone_context)\n assert_that(reminder.state, is_(occasional_buyer_notifier_states.idle))\n\n self.when_i_launch_all_occasional_buyer_notifier(in_days=106)\n\n launch_all_occasional_buyer_notifier()\n reminder.refresh_from_db()\n assert_that(reminder.state, is_(occasional_buyer_notifier_states.idle))\n assert_that(reminder.last_notification_time, not_none())\n assert_that(reminder.last_sold_date, equal_to(order.sold_date))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_validation_type__update__on_request_type_update(self) -> None:\n \"\"\"\n Given\n a request r1 on draft state with validation 1\n a request r2 on tms_transmission state with validation 1\n When i update request type validation type to 2\n Then\n r1 validation type is new one\n r2 validation type is old one\n \"\"\"\n site = self.any_site()\n r1 = self.any_request(site=site, state=request_states.draft)\n r2 = self.any_request(site=site, state=request_states.tms_transmission)\n request_type = site.requesttype_set.get(name=r1.type)\n old_validation_type = request_type.validation_type\n assert r1.validation_type == r2.validation_type\n\n new_validation_type = validation_types.all.difference(set(old_validation_type)).pop()\n request_type.validation_type = new_validation_type\n request_type.save()\n\n r1.refresh_from_db()\n r2.refresh_from_db()\n assert_that(r1.validation_type, is_(new_validation_type))\n assert_that(r2.validation_type, is_(old_validation_type))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_download_export(self) -> None:\n \"\"\"\n Given a request export in complete state with attachment\n When I load export\n Then 200 OK\n \"\"\"\n request_export = self.any_request_export(creator=self.client.user, state=request_export_states.completed)\n assert request_export.file\n attachment_file = request_export.file.file\n assert attachment_file\n self.when_i_load_export(request_export=request_export)\n assert_that(self.last_response, is_(http(200)))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_rules__no_permission(self) -> None:\n \"\"\"\n Given\n a user creator u1 with no role\n a global rule ON\n a request\n When I find users\n Then nothing is returned\n \"\"\"\n u1 = self.any_user(roles=[])\n request = self.any_request(state=\"draft\", creator=u1)\n self.any_global_rule(request_type=request.type, event=events.on_enter_state, state=request.state)\n\n users = notification_rules._find_users_to_notify(\n request=request, event=events.on_enter_state, old_state=request.state, state=request.state\n )\n\n assert_that(users, empty())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_permissions__team_request(self) -> None:\n \"\"\"\n Tests every quoted permission on every state for every roles and every request types (my / team / other)\n \"\"\"\n team_request = self.any_quoted_request(creator=self.u2, state=state)\n for role in permission_roles.all:\n u1 = self.any_user(roles=[role], sites=[self.site.uuid])\n self.any_team(with_users=[u1, self.u2], site=self.site)\n for perm in request_permissions.all:\n with self.subTest(role=role, perm=perm):\n team_expected = perm in expected.get(role, {}).get(\"team_request\", {})\n assert_that(u1.has_perm(perm, obj=team_request), is_(team_expected))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order_adapter__product_voucher(self) -> None:\n \"\"\"\n Given any order with order item with product voucher\n When I put it in OrderAdapter\n Then I get a valid message with\n - deal_info\n \"\"\"\n order = self.any_order(with_product_voucher=True)\n\n adapter = OrderAdapter()\n key = adapter.key(order)\n topic = adapter.topic(order)\n payload = adapter.as_data(order)\n data = payload[\"data\"][\"order_items\"][0]\n\n assert_that(key, is_(str(order.id)))\n assert_that(topic, is_(\"resource.kleen.order\"))\n assert_that(payload[\"uri\"], order.uri)\n\n assert_that(\n data,\n has_entry(\n \"deal_info\",\n has_entry(\"product_voucher\", True),\n ),\n )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_filter_request__team_requests_in(self) -> None:\n self.any_request(creator=self.client.user)\n requests_list = (\n RequestListPage.get(client=self.client, site_slug=self.client.sites[0].slug)\n .request_filter.apply(data={\"requests_type\": team_requests.mine}, next_page_class=RequestListPage)\n .requests_list\n )\n assert_that(requests_list, has_length(1))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order_from_twip_booking__no_deal(self) -> None:\n booking = BookingMixin().any_twip_api_booking(is_deal=False)\n order = OrderItem.objects.filter(booking_pk=booking.pk).first().order\n for order_item in order.orderitem_set.all():\n purchase = booking.purchase_set.filter(raw__uuid=str(order_item.purchase_pk)).first()\n assert purchase\n\n assert_that(\n order_item,\n has_properties(\n {\n \"orderitem_type\": order_item_types.booking,\n \"purchase_pk\": UUID(purchase.uuid),\n \"booking_pk\": booking.pk,\n \"price_before_discount\": decimal.Decimal(purchase.raw[\"price\"][\"incl_vat\"]).quantize(\n decimal.Decimal(\"0.000001\")\n ),\n \"price_after_discount\": decimal.Decimal(purchase.raw[\"price\"][\"incl_vat\"]).quantize(\n decimal.Decimal(\"0.000001\")\n ),\n \"price_after_discount_excl_tax\": decimal.Decimal(purchase.raw[\"price\"][\"excl_vat\"]).quantize(\n decimal.Decimal(\"0.000001\")\n ),\n \"currency_code\": purchase.raw[\"price\"][\"currency\"],\n }\n ),\n )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form__requested_time__timezone(self) -> None:\n request = self.any_request(state=request_states.draft, ready_to_submit=True)\n step = request.steps.first()\n data = self.any_step_form_data(steps=request.steps.all())\n data[\"steps-0-timezone\"] = \"Europe/Moscow\"\n data_date = request.creation_time + datetime.timedelta(days=1)\n data[\"steps-0-requested_time\"] = data_date\n data[\"steps-1-requested_time\"] = data_date\n formset = make_step_formset_class(instance=request, user=request.creator)(instance=request, data=data)\n assert_that(formset.is_valid(), is_(True))\n formset.save()\n step.refresh_from_db()\n tz = ZoneInfo(data[\"steps-0-timezone\"])\n assert_that(step.requested_time, is_(data_date.replace(tzinfo=tz)))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form__merge_carriage(self) -> None:\n \"\"\"\n Given a request with 2 step carriage\n When i save step form with one updated, one deleted and one new carriage\n Then it has been merged\n \"\"\"\n request = self.any_request(\n state=request_states.draft,\n ready_to_submit=True,\n with_packaging_units=False,\n with_carriages=True,\n with_step_units=False,\n )\n src_step, trg_step = request.steps.all()\n assert src_step\n assert src_step.step_packaging_units.count() == 0\n c_1 = request.carriages.first()\n assert c_1\n self.any_step_carriage(step=src_step, carriage=c_1)\n data = self.any_step_form_data(steps=request.steps.all())\n formset = make_step_formset_class(instance=request, user=request.creator)(instance=request, data=data)\n\n formset._merge_step_carriages(carriages=[c_1])\n\n assert_that(StepCarriage.objects.filter(step=src_step).all(), has_length(1))\n assert_that(StepCarriage.objects.filter(step=trg_step).all(), has_length(1))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promotional_offer_two_required_discounted_multiple_sequential(self) -> None:\n \"\"\"\n Given a station with promotional offer\n for a discounted item with two required items\n When\n I add two of each required item to cart\n I add discounted items to cart\n I add discounted items to cart\n Then the discounted items are discounted automatically\n \"\"\"\n cart = self.any_cart()\n promotional_offer = self.promotional_offer_multiple_discounted\n station = self.station\n required_deals, discounted_deals = promotional_offer.get_deals_for_station(station)\n discounted_deal = discounted_deals[0]\n required_deal_1 = required_deals[0]\n required_deal_2 = required_deals[1]\n\n self.add_item(cart, required_deal_1)\n self.add_item(cart, required_deal_2)\n self.add_item(cart, required_deal_1)\n self.add_item(cart, required_deal_2)\n self.add_item(cart, discounted_deal)\n self.add_item(cart, discounted_deal)\n\n assert_that(cart.cartitem_set.count(), is_(3))\n for cart_item in cart.cartitem_set.all():\n assert_that(cart_item.quantity, is_(2))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer(self) -> None:\n request = self.any_request(\n state=request_states.draft, with_attachments=[request_attachments.request_attachment]\n )\n serializer = RequestSerializer(request)\n assert_that(serializer.data, is_(request_data(request=request)))\n assert_that(serializer.data[\"attachments\"], has_length(request.attachments.count()))\n assert_that(serializer.data[\"packaging_units\"], has_length(request.packaging_units.count()))\n assert_that(serializer.data[\"steps\"], has_length(request.steps.count()))\n assert_that(serializer.data[\"groups\"], has_entries({\"code_1\": not_none()}))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_encode__incorrect_condition(self) -> None:\n \"\"\"\n Given a scenario with a condition with values incorrect (start_time > end_time)\n When I encode this scenario\n Then I get an exception described by a dict with entries for the fields incorrect\n \"\"\"\n contract = ContractMixin().any_climax_contract()\n hss = HssMixin().any_hss(user=contract.user, contract=contract, remote_proxy=remote_proxies.climax_kiz)\n condition = EveryWeekDaysFromToTempoClimax(\n pk=1,\n start_time=\"14:00:00\",\n end_time=\"11:00:00\",\n weekdays=\"monday,tuesday,wednesday,thursday,friday\",\n random=None,\n type=condition_types.every_week_days_from_to,\n )\n scenario_info = self.any_scenario_info(driver=hss.driver, condition=condition)\n scenario = self.any_scenario(hss=hss, state=states.draft, scenario_info=scenario_info, save=False)\n driver_decoder = self.any_driver_codec(hss.driver)\n with self.assertRaises(ValidationError) as e:\n driver_decoder.encode(scenario)\n assert_that(e.exception.error_dict, has_entries({\"start_time\": not_none(), \"end_time\": not_none()}))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_prepaid_account_amount(self) -> None:\n \"\"\"\n Given a user with a credit pack of 6€ redeemed\n When i get prepaid account amount\n Then i get a string == 6€\n \"\"\"\n user = self.any_user(with_credits=True)\n assert_that(user.prepaid_account_amount, is_(\"6.0€\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cart__update__promocode__offered_washing__remove(self) -> None:\n \"\"\"\n Given\n a cart with a promocode offered washing\n When i remove promocode from cart\n Then a cart item linked to a deal type offered washing doesn't exist anymore\n \"\"\"\n promocode = self.any_promocode(profile=promocode_profiles.v2_offered_wp, version=2)\n cart = self.any_cart(state=cart_states.active, with_promocode=True, promo_code=promocode)\n\n cart.update(promocode=None)\n\n assert_that(cart.offered_cartitems, empty())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_call(self) -> None:\n spec = SpecificationA()\n assert_that(spec(None), is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_name__polling_commit_response_decode_error(self) -> None:\n \"\"\"\n Given\n - a Hss with a honeywell panel\n - a HssDriver\n - a honeywell camera\n When\n - I update camera name with a polling response with wrong json\n Then\n - A ValueError is raises\n \"\"\"\n hss = self.any_configured_hss(account=default_honeywell_account)\n driver = driver_factory.get_driver(hss)\n with requests_mock.Mocker(real_http=True) as m:\n m.get(\n re.compile(r\"panel/devices/config/status\"),\n text=\"{}}\",\n status_code=200,\n )\n honeywell_camera = self.any_honeywell_camera(hss=hss)\n new_name = get_random_string(8)\n assert_that(\n calling(driver.cameras.update_name).with_args(camera_id=honeywell_camera.id, new_name=new_name),\n raises(BadResponse),\n )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_leave__from_initial(self) -> None:\n \"\"\"\n given a request in initial state\n when i leave\n then request is in dropped state\n \"\"\"\n request = self.any_quoted_request(state=request_states.initial, ready_to_submit=False)\n request.state_machine(user=request.creator).leave()\n assert_that(request.state, is_(request_states.dropped))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_signals__promotional_campaign_delete(self) -> None:\n promotional_campaign = self.any_promotional_campaign()\n with mock.patch(\"tw.replication.sites.ReplicationClient.unpublish\") as m: # noqa: RMS102\n promotional_campaign.delete()\n m.assert_called_once()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_str(self) -> None:\n camera = self.any_local_essentielle_camera()\n assert_that(str(camera), is_(f\"Camera {camera.id} [name: {camera.name}]\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_action_deactivate_promocodes(self) -> None:\n promocode = self.any_promocode()\n self.when_i_export_promocodes(action=\"deactivate_promocodes\", ids=[promocode.pk])\n promocode.refresh_from_db()\n assert_that(promocode.disabled, is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_fast_status_serializer(self) -> None:\n data = {\n \"Prom\": \"0031000001\",\n \"SiteId\": \"867430a0-fc58-4338-82ad-dcc2693c9668\",\n \"DiffusedDate\": \"2019-04-16T11:27:09.1458338+02:00\",\n \"OperatingState\": operation_states.on,\n }\n serializer = FastStatusEventSerializer(data=data)\n serializer.is_valid(raise_exception=True)\n assert_that(\n serializer.validated_data,\n has_entries(\n {\n \"Prom\": is_(\"0031000001\"),\n \"SiteId\": is_(\"867430a0-fc58-4338-82ad-dcc2693c9668\"),\n \"OperatingState\": is_(operation_states.on),\n \"DiffusedDate\": instance_of(datetime),\n }\n ),\n )\n serializer.process_event()\n\n prom = serializer.validated_data.get(\"Prom\")\n faststatus = FastStatusRedisClient(key_params_list=[prom]).get_fast_status()\n assert_that(faststatus, not_(none()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_serialize_scenario__invalid_action_data(self) -> None:\n \"\"\"\n Given : Scenario invalid data\n When : I serialize this data\n Then : I get a validation error\n \"\"\"\n hss = self.client.hss\n driver = hss.driver\n json_data = load(\"update_scenario_invalid_action_data.json\")\n serializer = CreateUpdateScenarioSerializer(data=json_data, context={\"hss\": hss, \"driver\": driver.scenarios})\n\n assert_that(calling(serializer.is_valid).with_args(raise_exception=True), raises(serializers.ValidationError))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_not_acknowledged_tms_transmission_false_timezone(self) -> None:\n \"\"\"\n Given a request in state tms_transmission with state_changed < 1hour\n and acknowledged_version != current request version\n When I try retrieve metric for not_acknowledged_tms_transmission\n Then I get a count = 0\n \"\"\"\n request = self.any_request()\n request.state_changed = timezone.now()\n request.acknowledged_versions.append(request.version + 1)\n request.save()\n with patch(\"datadog.DogStatsd.gauge\") as m:\n site.collect()\n assert_that(m.call_args_list, has_item(call(\"iwp_myroad.request_not_acknowledged\", 0)))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve__not_found(self) -> None:\n self.client = AuthenticatedClient()\n self.when_i_retrieve_checkout(checkout_id=1234)\n\n assert_that(self.last_response, http(404))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promotional_offer_discounted_multiple_remove_discounted(self) -> None:\n \"\"\"\n Given a cart with promotional offer for a discounted item having two items\n When I remove a discounted item\n Then\n One discounted item is left\n Two required items are left\n \"\"\"\n cart = self.any_cart()\n promotional_offer = self.promotional_offer_discounted\n station = self.station\n required_deal, discounted_deals = promotional_offer.get_deals_for_station(station)\n discounted_deal = discounted_deals[0]\n required_deal = required_deal[0]\n self.add_item(cart, required_deal, quantity=2)\n self.add_item(cart, discounted_deal, quantity=2)\n\n cart_item_discounted = cart.cartitem_set.filter(deal=discounted_deal).first()\n assert_that(cart_item_discounted, is_not(None))\n self.remove_item(cart, cart_item_discounted)\n assert_that(cart.cartitem_set.count(), is_(2))\n\n cart_item_1 = cart.cartitem_set.filter(deal=required_deal).first()\n assert_that(cart_item_1, is_not(None))\n assert_that(cart_item_1.quantity, is_(2))\n cart_item_2 = cart.cartitem_set.filter(deal=discounted_deal).first()\n assert_that(cart_item_2, is_not(None))\n assert_that(cart_item_2.quantity, is_(1))\n\n assert_that(\n cart.meta,\n has_entries(\n {\n \"promotional_offers\": has_entries(\n {\n \"used_cart_items\": contains(\n has_entries(\n {\"id\": str(cart_item_1.id), \"quantity\": 1, \"offer_id\": str(promotional_offer.uuid)}\n )\n ),\n \"offered_cart_items\": contains(\n has_entries({\"id\": str(cart_item_2.id), \"offer_id\": str(promotional_offer.uuid)})\n ),\n }\n ),\n }\n ),\n )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_serialize_scenario__state_unpublishing(self) -> None:\n \"\"\"\n Given : A scenario with state == unpublishing\n When : I serialize this scenario\n Then : I get a dict corresponding to the scenario i serialized, state == fail\n \"\"\"\n hss = self.client.hss\n driver = hss.driver.scenarios\n scenario = self.any_scenario(hss=hss)\n scenario.state = states.unpublishing\n serializer = ScenarioSerializer(instance=scenario, context={\"driver\": driver})\n assert_that(serializer, is_not(none()))\n data = serializer.data\n assert_that(data, has_entries({\"pk\": is_(scenario.pk), \"model\": \"scenario.scenario\", \"fields\": not_none()}))\n scenario_data = data[\"fields\"]\n assert_that(scenario_data, has_entry(\"state\", states.fail))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order__from_cross_selling(self) -> None:\n \"\"\"\n Given an order with a deal for a washing program\n When I complete this order with from_cross_selling = True\n Then the order item from_cross_selling is True\n \"\"\"\n user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n wp = self.any_washing_program(profile=washing_program_profiles.kleen)\n deal = self.any_deal(washing_program=wp)\n cart = self.any_cart(user=user, state=cart_states.empty)\n cart.add_item(deal=deal, from_cross_selling=True)\n\n order = self.any_order(user=user, payment_method=payment_methods.mangopay, cart=cart)\n\n assert_that(order.orderitem_first.from_cross_selling, is_(True))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_hss_status_serialization__probe_alert(self) -> None:\n \"\"\"\n Given probe in alert status\n Given an hss kiz 3 (climax + home_automation)\n When i serialize\n Then status is unknow\n \"\"\"\n probe = Probe.objects.get()\n probe.status = status.alert\n probe.save()\n self.client.hss.site.contract.refresh_from_db()\n\n hss_status_pk = \"hss_status_1\"\n source = sources.application_read_status\n timestamp = int(time.time() * 10e5)\n operating_state = operation_states.off\n raw_status = operation_states.reverse_mapping_operating_state[operating_state]\n faststatus = FastStatus(\n identifier=hss_status_pk, source=source, timestamp=timestamp, raw_status=raw_status, group=None\n )\n serializer = HssStatusSerializer(instance=faststatus)\n data = serializer.data\n assert_that(data[\"fields\"][\"is_incident_detected\"], is_(True))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_scenarios_maia_error(self) -> None:\n \"\"\"\n When I list scenario with maia error\n Then 502\n \"\"\"\n with requests_mock.Mocker() as m:\n m.get(requests_mock.ANY, status_code=500)\n last_response = self.when_i_list_scenarios()\n assert_that(last_response.status_code, is_(502))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_process_user_response__json_decode_error(self) -> None:\n driver = IMTDriver()\n account = default_climax_account\n with mock.patch(\"requests.Response.json\", side_effect=JSONDecodeError(\"test\", \"test\", 0)): # noqa: RMS102\n assert_that(\n calling(driver.read_user).with_args(\n country_code=account.country_code, subscriber_id=account.subscriber_id\n ),\n raises(AuthenticationException),\n )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_type_universe(self) -> None:\n \"\"\"\n Given : 6 inital scenarios type universe for panel_type hme_ip, 3 with country_code 'fr',\n 3 with country_code 'it'\n When : I list scenario type universe\n Then : Http response is 200, response contain 3 Scenario Type\n \"\"\"\n last_response = self.when_i_list_scenario_type_universe()\n assert_that(last_response.status_code, is_(200))\n assert_that(last_response.json(), has_length(5))\n for scenario_type_data in last_response.json():\n assert_that(scenario_type_data, has_entry(\"pk\", is_not(none())))\n scenario_type = ScenarioType.objects.get(pk=scenario_type_data[\"pk\"])\n assert_that(scenario_type.country_code, equal_to_ignoring_case(self.client.user.country_code))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_deal_form_market_place_coupon_program_price_less_than_zero(self) -> None:\n washing_program = self.any_washing_program__market_place()\n washing_program.price = decimal.Decimal(\"0\")\n washing_program.save(update_fields=[\"price\"])\n data = {\n \"type\": deal_types.washing,\n \"tax_percentage\": \"20.00\", # 20 %\n \"price_after_discount_basic\": \"12\",\n \"washing_program\": washing_program.pk,\n \"availability\": deal_availability.in_stock,\n }\n\n deal_form = DealForm(data)\n\n self.then_deal_form_is_invalid(deal_form)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_scenarios__second_user(self) -> None:\n \"\"\"\n Given : A dict representing a scenario with new condition for a user\n When : I put this dict for a second user\n Then : I get a 404 HTTP response\n \"\"\"\n self.client = ClimaxEssentiellePapillonClientAPI()\n client = EssentielleHandlerClient()\n hss = client.hss\n driver = hss.driver\n scenario = self.any_scenario(hss=client.hss)\n condition = DatetimeTempoClimax(1, \"12:00:00\", condition_types.with_datetime)\n scenario.scenario_type.tempo_condition_type.append(TempoConditionType.ONTHE_AT)\n scenario.scenario_type.save()\n new_scenario_info = ScenarioInfo(\n condition=condition,\n actions=[\n scenario.info.actions[0],\n ],\n remote_proxy=driver.hss.remote_proxy,\n )\n scenario.info = new_scenario_info\n data = self.any_scenario_data(scenario)\n last_response = self.when_i_update_scenario(data, scenario.pk)\n assert_that(last_response.status_code, is_(404), last_response.content)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter_additional_quote_quantity_3_framed(self) -> None:\n \"\"\"\n Given a framed request\n When I use RequestFormatter with 'additional_quote_quantity_3' field to export\n Then it return a dict that contain request additional_quote_quantity_3\n \"\"\"\n request = self.any_framed_request()\n request_csv = RequestFormatter().to_csv(request, fields=[\"additional_quote_quantity_3\"])\n assert_that(request_csv[0], is_(empty()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_formattedtimefield(self) -> None:\n timefield = \"06:00\"\n assert_that(\n FormattedTimeField().to_representation(timefield),\n is_(\n (FormattedTimeField().to_representation(datetime.strptime(timefield, \"%H:%M\").time())),\n ),\n )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form_invalid__negative(self) -> None:\n zone_context = self.any_zone_context()\n data = {\"discount\": -10, \"percentage\": 0, \"zone_context\": zone_context.pk}\n form = GivePromocodeForm(issue=None, data=data)\n assert_that(form.is_valid(), is_(False))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_begin(self) -> None:\n state_scenarios = [{\"actual\": request_states.planned, \"expected\": request_states.in_progress}]\n for scenario in state_scenarios:\n with self.subTest(scenario=scenario):\n request = self.any_framed_request(state=scenario[\"actual\"], creator=self.client.user)\n with handle_shipping_record_notifications():\n RequestActionPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk).form.begin()\n request.refresh_from_db()\n assert_that(request.state, is_(scenario[\"expected\"]))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_global_discount(self) -> None:\n \"\"\"\n Given any order with global discount promocode\n Then promocode_type is cart_discount_percentage\n \"\"\"\n user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n product = self.any_product()\n promocode = self.any_promocode(profile=promocode_profiles.washing_discount, version=1)\n promocode.products.add(product)\n\n deal = self.any_deal(washing_program=self.any_washing_program(product=product))\n\n cart = self.any_cart(user=user, state=cart_states.empty)\n cart.add_item(deal=deal)\n cart.update(promocode=promocode)\n\n user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n order = self.any_order(user=user, payment_method=payment_methods.mangopay, cart=cart)\n assert_that(order.promocode_type, is_(\"cart_discount_percentage\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list__unauthenticated(self) -> None:\n self.client = Client()\n self.when_i_list_addresses()\n assert_that(self.last_response.status_code, is_(status.HTTP_403_FORBIDDEN))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_tl12(self) -> None: # pragma: no cover # noqa: RMS201\n \"\"\"\n Given\n a tl12 program\n a deal with this program\n a cart with this deal\n a checkout with this cart\n When order is success\n Then order item has a code length 8\n \"\"\"\n washing_program = self.any_washing_program(profile=washing_program_profiles.tl12)\n deal = self.any_deal(washing_program=washing_program)\n cart = self.any_cart(deal=deal, state=cart_states.active)\n checkout = self.any_checkout(cart=cart, state=checkout_states.ordered)\n\n order = checkout.order\n\n assert_that(order.status, is_(order_states.success))\n order_item = order.orderitem_set.first()\n assert_that(order_item.coupon_code, has_length(8))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_checkout__pending__remove_prepaid_account(self) -> None:\n \"\"\"\n Given\n a cart prepaid account linked\n when i start checkout\n then checkout is in remove_prepaid_account state\n \"\"\"\n user = self.any_user(mangopay_card=mangopay_cards.normal)\n cart = self.any_cart(\n user=user, state=cart_states.active, prepaid_account_profile=cart_prepaid_account_profiles.personal\n )\n checkout = self.any_checkout(\n cart=cart,\n state=checkout_states.pending,\n payment_method=self.PAYMENT_METHOD,\n with_ip_address=True,\n with_browser_info=True,\n )\n checkout.refresh(consumer=checkout.cart.user.consumer_set.first())\n\n assert_that(checkout.state, equal_to(checkout_states.remove_prepaid_account))\n assert_that(checkout.order_id, none())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer(self) -> None:\n \"\"\"\n Given:\n - a \"devices\" instance composed by (a powerswitch, a blind, a camera,\n a thermometer, an opening detector, a siren, a keypad, an emergency key,smoke detector,\n flood detector, remote control, ir detector)\n When:\n - I serialize it\n Then:\n - I get a valid json\n \"\"\"\n devices = self.any_devices()\n serializer = DevicesSerializer(devices)\n data = serializer.data\n assert_that(data, has_entries({\"pk\": devices.id, \"model\": \"hss.devices\", \"fields\": anything()}))\n assert_that(\n data[\"fields\"],\n has_entries(\n {\n \"camera_set\": not_none(),\n \"blind_set\": not_none(),\n \"powerswitch_set\": not_none(),\n \"thermometer_set\": not_none(),\n \"opening_detector_set\": not_none(),\n \"siren_set\": not_none(),\n \"keypad_set\": not_none(),\n \"ir_detector_set\": not_none(),\n \"smoke_detector_set\": not_none(),\n \"flood_detector_set\": not_none(),\n \"remote_control_set\": not_none(),\n \"emergency_key\": has_entries(\n {\"pk\": anything(), \"model\": \"hss.emergency_key\", \"fields\": anything()}\n ),\n }\n ),\n )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_decode(self) -> None:\n \"\"\"\n Given\n a panel scenario with valid condition / action\n When I decode\n Then ScenarioInfo has valid condition / action\n \"\"\"\n contract = ContractMixin().any_climax_contract()\n hss = HssMixin().any_hss(user=contract.user, contract=contract, remote_proxy=remote_proxies.climax_kiz)\n driver_scenario = self.any_driver_scenario(\n scenario_driver=hss.driver.scenarios, condition=\"a1.mode==1\", action=\"a=1&z=6&sw=off\"\n )\n coder = self.any_driver_codec(driver=hss.driver)\n info, targets = coder.decode(scenario=driver_scenario)\n assert_that(info, not_none())\n assert_that(info.condition, not_none())\n assert_that(info.condition, instance_of(PanelStatusConditionClimax))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_carriage(self) -> None:\n request = self.any_request(\n state=request_states.initial,\n ready_to_submit=True,\n creator=self.client.user,\n with_step_units=False,\n with_packaging_units=False,\n with_carriages=True,\n )\n page = RequestUpdateStepsPage.get(\n client=self.client, site_slug=request.site.slug, pk=request.pk\n ).form.add_carriage()\n assert_that(page, instance_of(RequestUpdateStepsPage))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_product_discount__credit_pack_discount__prices(self) -> None:\n \"\"\"\n Given any any promocode for discount on credit_pack\n When I use this promocode with product in cart\n Then orderitem has:\n - corrected_price_before_discount is equalt to credits_pack_price\n - corrected_price_after_discount is equal to price_after_discount minus promocode discount percentage\n - price_before_discount is not equal to corrected_price_before_discount\n - price_after_discount is not equal to corrected_price_after_discount\n \"\"\"\n\n user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n credits_pack = self.any_credits_pack()\n promocode = self.any_promocode(profile=promocode_profiles.v2_cart_discount_percentage, version=2)\n promocode.valid_for_credits_pack = credits_pack\n promocode.save()\n deal = self.any_deal(\n price_after_discount=decimal.Decimal(\"10\"),\n price_before_discount=decimal.Decimal(\"15\"),\n profile=deal_profiles.credits_pack,\n credits_pack=credits_pack,\n )\n\n cart = self.any_cart(user=user, state=cart_states.empty)\n cart.add_item(deal=deal)\n cart.update(promocode=promocode)\n\n order = self.any_order(user=user, payment_method=payment_methods.mangopay, cart=cart)\n\n assert_that(order.promocode_type, is_(\"product_discount\"))\n orderitem = order.orderitem_set.get()\n\n assert_that(\n orderitem.corrected_price_after_discount,\n is_(\n orderitem.price_before_discount\n - orderitem.price_before_discount * order.cart.promocode.discount_percentage / decimal.Decimal(\"100\")\n ),\n )\n assert_that(orderitem.price_after_discount, not_(orderitem.corrected_price_after_discount))\n assert_that(orderitem.price_before_discount, not_(orderitem.corrected_price_before_discount))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_replication__on_creation(self) -> None:\n \"\"\"\n When I create user quoted notifications settings\n Then resource kafka message is send\n \"\"\"\n with assert_signal_called(obj_published, matcher=greater_than_or_equal_to(1)):\n self.any_user_quoted_notifications_settings()\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__site(self) -> None:\n \"\"\"\n Given any user framed notification settings with any site\n When I serialized it\n Then I get valid json representation\n \"\"\"\n site = SiteMixin().any_site()\n settings = self.any_user_framed_notifications_settings(site=site)\n data = UserFramedNotificationsSettingsSerializer(instance=settings).data\n assert_that(data[\"site\"], is_(site.myroad_uri.value))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve_order__prepaid_account_mangopay(self) -> None:\n \"\"\"\n Given an order with prepaid_account_mangopay\n When I describe order\n Then I get\n - a 200 OK\n - payment_share_mangopay equal to sold_price\n - payment_share_prepaid_account equal to prepaid_account_used_incl_vat\n \"\"\"\n\n self.client = AuthenticatedClient(with_credits=True, credits=1000)\n\n deal = self.any_deal()\n cart = self.any_cart(user=self.client.user, state=cart_states.empty)\n cart.add_item(deal=deal)\n cart.update(prepaid_account=self.client.user.personal_prepaid_account)\n\n order = self.any_order(\n user=self.client.user,\n payment_method=payment_methods.prepaid_account_mangopay,\n cart=cart,\n api_version=self.API_VERSION,\n )\n\n self.when_i_retrieve_order(order_pk=order.pk)\n\n assert_that(self.last_response.status_code, is_(200))\n assert_that(\n self.last_response.data[\"fields\"],\n has_entries({\"sold_price\": str(order.sold_price.quantize(Decimal(\"0.01\")))}),\n )\n assert_that(\n self.last_response.data[\"fields\"][\"payment_details\"],\n has_entries(\n {\"prepaid_account_used_incl_vat\": str(order.prepaid_account_used_incl_vat.quantize(Decimal(\"0.01\")))}\n ),\n )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_file(self, *mocks) -> None:\n # given :\n # - A user natural\n # - A document with status CREATED of type IDENTITY_PROOF\n # When :\n # - I add file\n # - I update document\n # Then\n # - Document is status validation_asked\n mangopay_user = self.any_user_with_mangopay_account()\n document = self.any_mangopay_document(\n account=mangopay.get_account(mangopay_user),\n type=DOCUMENTS_TYPE_CHOICES.identity_proof,\n status=DOCUMENTS_STATUS_CHOICES.validation_asked,\n )\n self.assertEqual(document.status, DOCUMENTS_STATUS_CHOICES.validation_asked)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_notify_users__quoted_on_enter_state__cancelled(self) -> None:\n \"\"\"\n Given\n a quoted request in cancelled state\n a global rule set as \"should_send\" for aborted state\n When I call \"notify_users\"\n Then \"send_mail\" is called\n \"\"\"\n request = self.any_quoted_request(state=request_states.cancelled)\n self.any_global_rule(request_type=request.type, event=events.on_enter_state, state=request_states.aborted)\n mail.outbox.clear()\n notification_rules.notify_users(\n request=request, event=events.on_enter_state, old_state=request.state, state=request.state\n )\n assert_that(mail.outbox, has_length(1))\n assert_that(mail.outbox[0].body, contains_string(\"a été annulée\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_delivery__expiration(self) -> None:\n \"\"\"\n Given a delivery with lifetime dispenser made 1 hour\n Then archived is True\n \"\"\"\n one_hour_ago = timezone.now() - timezone.timedelta(hours=1)\n with freeze_time(one_hour_ago, tick=True):\n washing_program = self.any_washing_program(profile=washing_program_profiles.none)\n dispenser = self.any_human_dispenser(station=washing_program.station)\n self.any_dispenser_params(\n dispenser=dispenser, washing_program=washing_program, lifetime=timezone.timedelta(hours=1)\n )\n deal = self.any_deal(washing_program=washing_program)\n order = self.any_order(deal=deal)\n delivery = self.any_delivery(order=order)\n assert_that(delivery.archived, is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(NEED_DEFAULT_PROMOCODE=True)\ndef test_update__anonymous(self) -> None:\n self.client = AnonymousClient()\n self.when_i_create_card_registration()\n\n assert_that(self.last_response, http(403))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__invalid(self) -> None:\n climax_panel_cond_post_json = load(\"climax_panel_device_post_invalid.json\")\n serializer = UpdateResponseSerializer(data=climax_panel_cond_post_json)\n assert_that(calling(serializer.is_valid).with_args(raise_exception=True), raises(ValidationError))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_resynchro_scenario_with_exception(self) -> None:\n \"\"\"\n Given the hss of account test.ripplemotion@gmail.com\n with a scenario published with is_on == True and unknow source_id list\n with a scenario published with is_on == True and correct source_id\n When I resynchro scenarios\n Then the scenario with unknow source_id list is in state ready, is_on == False, source_id == None\n the scenario with correct source_id is unchanged\n \"\"\"\n hss = ClimaxHandlerClient().hss\n hss.remote_proxy = remote_proxies.climax_kiz\n hss.save()\n scenario_correct = self.any_scenario(hss=hss, state=states.published)\n scenario = self.any_scenario(hss=hss)\n scenario.source_id = []\n scenario.is_on = True\n scenario.state = states.published\n\n scenario.save()\n with mock.patch.object(HomeSecuritySystem, \"scenarios\", return_value=None): # noqa: RMS102\n with mock.patch( # noqa: RMS102\n \"django.db.models.query.QuerySet.delete\", side_effect=[Exception, Exception, Exception, Exception]\n ):\n # with mock.patch(\"\", return_value=[0]):\n hss = hss.resynchro_scenario()\n scenario.refresh_from_db()\n assert_that(scenario.state, is_(states.published))\n assert_that(scenario.is_on, is_(True))\n assert_that(scenario_correct.state, is_(states.published))\n assert_that(scenario_correct.is_on, is_(True))\n assert_that(scenario_correct.source_id, is_not(none()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_ios_set_later_after_later(self) -> None:\n \"\"\"\n Given a registered user that has chosen to rate the app later\n When he chooses to rate the app later again\n Then the AppRating for android is set to later\n \"\"\"\n user = self.any_user()\n app_rating = self.any_app_rating(user, ios_state=app_rating_state.later)\n\n serializer = SetAppRatingSerializer(\n instance=app_rating,\n data={\"user\": user.id, \"state\": app_rating_state.later, \"consumer_name\": oauth_consumer_name.android},\n )\n\n serializer.is_valid(raise_exception=True)\n app_rating = serializer.save()\n self.assertEqual(app_rating.ios_state, app_rating_state.later)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_um__does_not_increment_request_version(self) -> None:\n request = self.any_framed_request(state=request_states.initial)\n request_version = request.version\n request = request.state_machine(user=request.creator).add_um().request\n assert_that(request.version == request_version)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_corporation_invoice_bill_dir(self) -> None:\n path = corporation_invoice_bill_dir(None, self.filename)\n expected_path = f\"bill/corporation-invoice_bill/{self.date.strftime('%Y/%m/%d')}/test_file.txt\"\n self.assertEqual(path, expected_path)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_is_specific__depth(self) -> None:\n \"\"\"\n Given a request without pu\n When i save form with specific height (> 13,5m)\n Then request is specific load_type\n \"\"\"\n request = self.any_request(state=request_states.draft, ready_to_submit=False)\n data, files = self.any_packaging_unit_form_data(\n packaging_units=request.packaging_units.all(), with_extra=True, prefix=\"packaging_units\"\n )\n data[\"packaging_units-0-size_0\"] = \"13501\"\n formset = make_pu_formset_class(instance=request, user=request.creator)(\n instance=request, data=data, files=files\n )\n assert formset.is_valid()\n formset.save()\n\n request.refresh_from_db()\n assert_that(request.load_type, is_(load_types.specific))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request__on_accepted_quote(self) -> None:\n \"\"\"\n Given a request in state quote_proposal\n When a request on_accepted_quote\n Then the request history_quote is in state accepted\n \"\"\"\n request = self.any_quoted_request(state=request_states.quote_proposal)\n\n history_count_before = request.history_quotes.count()\n request = self.do_on_accepted_quote(request=request)\n history_count_after = request.history_quotes.count()\n history_quote = request.history_quotes.order_by(\"revision\").last()\n\n assert_that(history_count_after, is_(history_count_before))\n assert_that(history_quote, not_none())\n assert_that(history_quote.state, is_(HistoryQuoteStates.ACCEPTED))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order__credit_pack(self) -> None:\n \"\"\"\n Given an credit pack order in success state\n Then payline transaction has order_reference_detail.credits_pack\n \"\"\"\n user = self.any_user(with_total_gr_card=True)\n order = self.any_order(\n user=user,\n status=order_states.success,\n profile=order_profiles.credits_pack,\n payment_method=self.PAYMENT_METHOD,\n )\n\n transactions = Transaction.objects.filter(options__order_id=order.id)\n assert_that(transactions, not_none())\n assert_that(transactions[0].order_detail_reference, is_(order_detail_references.credits_pack))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_promocode(self) -> None:\n self.client = AuthenticatedClient()\n code = self.any_promo_code(is_listed=True)\n self.when_i_list_promo_code()\n self.then_http_status_is(200)\n\n promo_code = self.last_response.data\n fields = promo_code[0][\"fields\"]\n self.assertTrue(fields[\"code\"])\n self.assertEqual(fields[\"code\"], code.code)\n self.assertTrue(fields[\"price\"])\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_policies_about(self) -> None:\n \"\"\"\n Given many policies about, an authenticated user\n When I list policies about\n Then I get a response with :\n - a code 200\n - only Wash app policies\n \"\"\"\n policy_1 = self.any_policy(tos_type=TosType.MANGOPAY_POLICY)\n policy_2 = self.any_policy(tos_type=TosType.KLEEN_COOKIES_POLICY)\n policy_3 = self.any_policy(tos_type=TosType.KLEEN_TOU)\n policy_4 = self.any_policy(tos_type=TosType.KLEEN_TOS_MARKETPLACE)\n policy_5 = self.any_policy(tos_type=TosType.KLEEN_TOS_MARKETPLACE_TWIP_WEB)\n policy_6 = self.any_policy(tos_type=TosType.KLEEN_TOS_POLICY_WEBSITE)\n self.when_i_list_policies_about()\n assert_that(self.last_response, http(200))\n assert_that(self.last_response.json(), has_length(4))\n assert_that(\n self.last_response.json()[0],\n has_entries(\n {\n \"model\": \"policy.policy\",\n \"fields\": has_key(\"tos_type\"),\n \"pk\": any_of(\n is_(policy_1.model_pk), is_(policy_2.model_pk), is_(policy_3.model_pk), is_(policy_4.model_pk)\n ),\n }\n ),\n )\n assert_that(\n self.last_response.json()[0],\n has_entries(\n {\n \"model\": \"policy.policy\",\n \"fields\": has_key(\"tos_type\"),\n \"pk\": not_(\n any_of(\n is_(policy_5.model_pk),\n is_(policy_6.model_pk),\n )\n ),\n }\n ),\n )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenarios__incorrect_hss(self) -> None:\n \"\"\"\n Given : A scenario\n When : I list scenarios, for an unexistent hss\n Then : I get a 404 HTTP response\n \"\"\"\n self.any_scenario(hss=self.client.hss)\n last_response = self.when_i_list_scenarios(hss_pk=1234)\n assert_that(last_response.status_code, is_(404))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_read_not_implemented(self) -> None:\n hss = self.any_hss()\n driver = PanelStatusDriver(hss)\n with self.assertRaises(NotImplementedError):\n driver.read()\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter_additional_quote_quantity_3_quoted(self) -> None:\n \"\"\"\n Given a quoted request\n When I use RequestFormatter with 'additional_quote_quantity_3' field to export\n Then it return a dict that contain request additional_quote_quantity_3\n \"\"\"\n request = self.any_quoted_request(with_additional_quotes=True)\n additional_quote = request.additionalquote_set.first()\n assert isinstance(additional_quote, AdditionalQuote)\n additional_quote.quantity = 12\n additional_quote.label = \"Test\"\n additional_quote.full_clean()\n additional_quote.save()\n request_csv = RequestFormatter().to_csv(request, fields=[\"additional_quote_quantity_3\"])\n assert_that(request_csv[0], is_(12))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer_update_name(self) -> None:\n data = {\"name\": \"updated name\"}\n serializer = UpdateIRDetectorSerializer(data=data)\n serializer.is_valid(raise_exception=True)\n assert_that(serializer.data[\"name\"], is_(\"updated name\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cart_item_create_form__with_prepaid_account_limit_exceeded(self) -> None:\n \"\"\"\n Given a user with:\n a cart\n a prepaid account with (settings.PREPAID_ACCOUNT_MAXIMUM_AMOUNT - 1)\n When I serialize a credit pack of 11€\n Then I get an exception indicating that the total of prepaid account + credit pack value exceed the limit\n \"\"\"\n cart = self.any_cart()\n personal_prepaid_account = cart.user.personal_prepaid_account\n personal_prepaid_account.credits = (settings.PREPAID_ACCOUNT_MAXIMUM_AMOUNT - 1) * 100\n personal_prepaid_account.save()\n deal_credits_pack = self.any_deal(profile=deal_profiles.credits_pack)\n data = {\"reference\": deal_credits_pack.pk, \"quantity\": 1, \"item_type\": create_cart_item_types.deal}\n form = CartItemCreateForm(data=data, cart=cart)\n assert_that(form.is_valid(), is_(False))\n assert_that(\n form.errors_as_detail_status(),\n has_entry(\"detail\", CartItemCreateForm.error_messages[CartItemCreateForm.PREPAID_ACCOUNT_EXCEED_LIMIT]),\n has_entry(\"status\", CartItemCreateForm.PREPAID_ACCOUNT_EXCEED_LIMIT),\n )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_movements_lighting(self) -> None:\n \"\"\"\n Given a hss\n Given data to create scenario movements_lighting\n When I create scenario\n Then 201 with data\n \"\"\"\n hss = self.client.hss\n power_switch_action = self.any_power_switch_action(\n driver=hss.driver,\n fields={\"status\": \"on\", \"duration\": 60},\n )\n scenario_info = self.any_scenario_info(driver=hss.driver, actions=[power_switch_action])\n scenario = self.any_scenario(\n scenario_info=scenario_info,\n hss=hss,\n scenario_type=ScenarioType.objects.filter(slug=\"movements-lighting\", remote_proxy=\"climax_kiz\").first(),\n )\n data = self.any_scenario_data(scenario)\n plug = self.any_local_device(type=DeviceType.plug)\n data[\"actions\"].append(\n {\"type\": \"hss.scenario.action.maia_plug\", \"fields\": {\"status\": \"on\", \"duration\": 60, \"device_pk\": plug.pk}}\n )\n data[\"condition\"] = {\n \"fields\": {\"status\": \"all\"},\n \"type\": \"hss.scenario.condition.panel_status\",\n \"collection_id\": None,\n }\n last_response = self.when_i_post_scenario(data)\n assert_that(last_response.status_code, is_(201), last_response.content)\n assert_that(last_response.json(), is_(not_none()))\n assert_that(MasterScenario.objects.count(), is_(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_migrate_favorites__invalid(self) -> None:\n \"\"\"\n Given a an Hss with honeywell panel\n When I ask the migrate the favorites from 3.4.x to 3.5.x\n Then I get a suite of 3.5.x compatible favorites\n \"\"\"\n hss = self.any_configured_hss(account=test_kiz3_account)\n hss.favourite_elements = \"ircam\" # digitalalchon\n driver = driver_factory.get_driver(hss)\n migrated_elements = driver.devices.migrate_favorites(hss.favourite_elements)\n assert_that(migrated_elements, is_(\"\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_transaction_creation__order(self) -> None:\n\n transaction = self.any_transaction(order_profile=order_profiles.marketplace_tmf)\n assert transaction\n\n order = Order.objects.first()\n oi = order.orderitem_first\n assert_that(transaction.related_deal, is_(oi.washingprogram_name))\n assert_that(transaction.related_tax, is_(order.sold_price_tax))\n", "output": "2"}