train_code.jsonl

{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order_refund__prepaid(self) -> None:\n    \"\"\"\n    Given an order succeeded with prepaid account\n    When i change state to refund\n    Then order is in refunded state, prepaid account is back to initial balance value\n    \"\"\"\n    user = self.any_user(mangopay_card=mangopay_cards.normal)\n    order = self.any_order(\n        user=user, with_prepaid_account=True, payment_method=payment_methods.prepaid_account_mangopay\n    )\n    credits = order.user.personal_prepaid_account.credits\n    order.change_to_refunded()\n    used_credits = order.prepaid_account_used_incl_vat * 100\n    assert_that(order.status, is_(order_states.refunded))\n\n    assert_that(order.user.personal_prepaid_account.credits, equal_to(credits + used_credits))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request__additional_quotes(self) -> None:\n    \"\"\"\n    Given a request with additional_quotes\n    When i load message\n    Then request has one additional quote\n    \"\"\"\n    msg = load(\"request_framed_draft.json\")\n    request = RequestLoader().on_message(RequestLoader.TOPIC, msg)\n    assert isinstance(request, Request)\n\n    additional_quote = request.additionalquote_set.get()\n    assert_that(additional_quote.id, is_(300))\n    assert_that(additional_quote.label, is_(\"MyLabel\"))\n    assert_that(additional_quote.unit_price_excl_vat, is_(Decimal(\"5.00\")))\n    assert_that(additional_quote.quantity, is_(5))\n    assert_that(additional_quote.comment, is_(\"\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_loader(self) -> None:\n    json = load(\"no_wash_station.json\")\n    key = json[\"uri\"].split(\"/\")[-1]\n    no_wash_station = NoWashLoader().on_message(\"resource.tw.autowash\", json, key)\n    assert_that(\n        no_wash_station,\n        has_properties(\n            {\n                \"source_id\": \"autowash-ref://autowash/91d67138-8e18-11eb-8e4a-549f35079518\",\n                \"enabled\": True,\n                \"total_code\": \"NF081810\",\n            }\n        ),\n    )\n    self.any_no_wash_station()\n\n    assert_that(NoWashStation.objects.all().count(), equal_to(2))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_detail__with_washing_program(self) -> None:\n    station = self.any_station()\n    self.any_washing_program(station=station)\n    self.when_i_view_instance_details(station)\n    assert_that(self.last_response.status_code, is_(200))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_cart_item_product_voucher__affected_by_promotional_offer(self) -> None:\n    \"\"\"\n    Given a user with\n        - An empty cart\n        - A product voucher for product P1\n        - A deal affected by a promotional offer\n    When I add a washing program for product P1 to the cart\n    Then the cart have a new free deal\n    \"\"\"\n    self.any_product_voucher(\n        product=self.product, product_voucher_account=self.user.product_voucher_account_set.first()\n    )\n    cart = self.any_cart(state=cart_states.empty, user=self.user)\n    washing_program = self.any_washing_program(product=self.any_product(sku=\"test\"), station=self.wp.station)\n    self.any_deal(washing_program=washing_program)\n    self.any_promotional_offer(\n        station=self.wp.station, discounted_washing_program=washing_program, required_washing_program=self.wp\n    )\n\n    cart.add_item(deal=self.deal)\n\n    assert_that(cart.cartitem_set.all(), has_length(2))\n    assert_that(cart.cartitem_set.exclude(deal__promotional_offer=None), has_length(1))\n    assert_that(cart.cartitem_set.exclude(deal__promotional_offer=None).first().deal.product_voucher, is_(none()))\n    assert_that(cart.cartitem_set.exclude(deal__product_voucher=None), has_length(1))\n    assert_that(cart.cartitem_set.exclude(deal__product_voucher=None).first().deal.promotional_offer, is_(none()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_error_provider_tl12_dispenser_human(self) -> None:\n    station = self.any_station()\n    data = {\"dispenser_type\": Dispenser.TYPE_HUMAN, \"provider\": self.tl12_provider.pk, \"station\": station.pk}\n    form = DispenserForm(data)\n    is_valid = form.is_valid()\n\n    assert_that(is_valid, is_(False))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form__wrong_code__last_try(self) -> None:\n    \"\"\"\n    Given\n        - a user without validate mobile phone with check retry equal to 5 (last try)\n        - an invalid code\n    When i valid\n    Then form is invalid and user is a frauder with phone_validation_fail\n    \"\"\"\n    user = self.any_user(with_mobile_phone_verified=False)\n    user.mobile_phone_to_verify_verification_retries = 5\n    user.save()\n    form = CheckMobilePhoneForm(data={\"code\": \"wron\"}, context={\"user\": user})\n    assert_that(form.is_valid(), is_(False))\n    assert_that(user.is_frauder, is_(True))\n    assert_that(user.mobile_phone_to_verify_verification_retries, equal_to(0))\n    assert_that(user.frauder_reason, is_(frauder_reasons.phone_validation_fail))\n    assert_that(user.last_frauder_update, is_(not_none()))\n    assert_that(user.last_frauder_update - timezone.now(), less_than(timedelta(minutes=1)))\n    assert_that(\n        form.errors,\n        is_(\n            {\n                \"code\": [\n                    \"\"\"Par mesure de sécurité, votre compte a été suspendu pendant 24H.\\nSi vous souhaitez le réactiver, vous pouvez nous contacter via la rubrique \"A propos\" > \"Aide et suggestions\" de l'application.\"\"\"  # noqa\n                ]\n            }\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_redeeming__frauder_by_admin(self) -> None:\n    \"\"\"\n    Given a delivery and user frauder by admin\n    When I archive\n    Then 403\n    \"\"\"\n    self.client = AuthenticatedClient()\n    self.client.user.is_frauder = True\n    self.client.user.frauder_reason = frauder_reasons.by_admin\n    self.client.user.last_frauder_update = timezone.now()\n    order = self.any_order(user=self.client.user, api_version=CURRENT_API_VERSION)\n    delivery = self.any_delivery(order=order, api_version=CURRENT_API_VERSION)\n\n    self.when_i_post_delivery_redeem(delivery_id=delivery.id)\n\n    assert_that(self.last_response, http(403))\n    assert_that(\n        self.last_response.json(),\n        has_entry(\n            \"detail\",\n            \"\"\"Par mesure de sécurité, votre compte a été suspendu. \\nSi vous souhaitez le réactiver, vous pouvez nous contacter via la rubrique “A propos” > “Aide et suggestions” de l’application.\"\"\",  # noqa\",\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_writer_event(self) -> None:\n    bo = MangoPayFixture().any_browser_info()\n    ip_a = \"192.168.1.1\"\n    us = self.any_user_subscription(state=UserSubscriptionState.NEED_CIT_PAYMENT)\n    with assert_signal_called(\n        obj_published, matcher=1, kwargs_matchers={\"obj\": instance_of(SubscriptionOrderGeneratedEvent)}\n    ):\n        us.start_cit_payment(bo, ip_a)\n    so = SubscriptionOrder.objects.get(user_subscription=us)\n    obj = SubscriptionOrderGeneratedEvent(subscription_order=so)\n    key = SubscriptionOrderGeneratedEventWriter().key(obj=obj)\n    topic = SubscriptionOrderGeneratedEventWriter().topic(obj=obj)\n    partition = SubscriptionOrderGeneratedEventWriter().partition(obj=obj)\n    data = SubscriptionOrderGeneratedEventWriter().data(obj=obj)\n    assert_that(\n        data,\n        has_entries(\n            {\n                \"uuid\": instance_of(str),\n                \"event\": \"subscription_order_generated\",\n                \"timestamp\": instance_of(int),\n                \"version\": is_(1),\n                \"revision\": is_(1),\n                \"data\": anything(),\n            }\n        ),\n    )\n    assert_that(topic, is_(\"events.kleen.subscriptionorder\"))\n    assert_that(key, is_(str(so.pk)))\n    assert_that(partition, is_(0))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_remove_common_cart_item__with__promotional_offer__product_voucher(self) -> None:\n    \"\"\"\n    Given a user with:\n        - a 3 products voucher for P1\n        - a promotional offer requiring P1 offering P2\n        - a common deal\n    When I remove the common deal\n    Then I have 3 washing program P1 offered and 1 washing program P2 with quantity 3\n    \"\"\"\n    discounted_washing_program = self.any_washing_program(\n        washing_type_specific=washing_program_types.vacuum_cleaner, station=self.wp.station\n    )\n    self.any_product_voucher(\n        product_voucher_account=self.user.product_voucher_account_set.first(), product=self.product\n    )\n    self.any_product_voucher(\n        product_voucher_account=self.user.product_voucher_account_set.first(), product=self.product\n    )\n    self.any_product_voucher(\n        product_voucher_account=self.user.product_voucher_account_set.first(), product=self.product\n    )\n    self.any_deal(washing_program=discounted_washing_program)\n    self.any_promotional_offer(\n        station=self.wp.station,\n        required_washing_program=self.wp,\n        discounted_washing_program=discounted_washing_program,\n    )\n    cart = self.any_cart(state=cart_states.active, user=self.user, deal=self.deal)\n    cart.add_item(deal=self.deal)\n    cart.add_item(deal=self.deal)\n    common_deal = self.any_deal()\n    cart.add_item(common_deal)\n    assert_that(cart.cartitem_set.all(), has_length(5))\n    assert_that(cart.cartitem_set.filter(deal__product_voucher__isnull=False), has_length(3))\n    assert_that(cart.cartitem_set.filter(deal__promotional_offer__isnull=False), has_length(1))\n    assert_that(cart.cartitem_set.filter(deal__promotional_offer__isnull=False).first().quantity, is_(3))\n    cart.remove_item(cart.cartitem_set.filter(deal=common_deal).first(), 1)\n    assert_that(cart.cartitem_set.all(), has_length(4))\n    assert_that(cart.cartitem_set.filter(deal__product_voucher__isnull=False), has_length(3))\n    assert_that(cart.cartitem_set.filter(deal__promotional_offer__isnull=False), has_length(1))\n    assert_that(cart.cartitem_set.filter(deal__promotional_offer__isnull=False).first().quantity, is_(3))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_submit_form__password_special_char(self) -> None:\n    \"\"\" \"\n    Given a valid delegation\n    When I submit the resgistration form with a valid email and a password with special char\n    Then ok\n    \"\"\"\n    delegation = self.any_delegation(enabled=True)\n    form = RegistrationPage.get(client=Client(), token=delegation.token).form\n    page = form.submit(data={\"email\": \"elbout@test.com\", \"password\": \"P=ssw0rd\"})\n    assert_that(\n        page.initial_response.wsgi_request.path,\n        is_(reverse(\"www:congratulations\", kwargs={\"token\": delegation.token})),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_transaction_duplicating__to_duplicate_failed(self) -> None:\n    payline_user = self.any_payline_user(with_card=False)\n    transaction = self.any_transaction(payline_user=payline_user, state=transaction_states.succeeded)\n    payline_user.card_token = \"invalid_token\"\n    payline_user.card_expiration_date = \"0519\"\n    payline_user.save()\n\n    transaction.duplicate()\n    transaction.wait_for_completion(waiting_states=transaction_states.duplicate_final)\n\n    assert_that(transaction.state, is_(transaction_states.duplicate_failed))\n    assert_that(transaction.duplicated_set, not_none())\n    assert_that(transaction.duplicated_set.count(), is_(greater_than(0)))\n\n    duplicated_tr = transaction.duplicated_set.first()\n    assert_that(duplicated_tr.state, is_(transaction_states.failed))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_complete__raw_none(self) -> None:\n    equipment = self.any_equipment()\n    equipment.raw = None\n    with self.assertRaises(IntegrityError):\n        equipment.save()\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_type_site__label(self) -> None:\n    \"\"\"\n    Given\n        an activated site param\n        a request type site parameter config\n    When i call parameter label\n    Then it shows the label value\n    \"\"\"\n    config = self.any_request_type_site_configuration()\n    request = self.any_request(site=config.site)\n    with activate(request=request):\n        value = parameter(name=config.definition.name, option_field=\"label\")\n    assert_that(value, is_(config.label))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_recover_api__unowned(self) -> None:\n    \"\"\"\n    Given an authenticated user, a scenario in state publishing_failed\n    When I try to recover this scenario which is not mine\n    Then I get an http response with status code 404\n    \"\"\"\n    second_client = ClimaxDigitaltikiz3APIClient()\n    scenario = self.any_scenario(hss=second_client.hss)\n    scenario.source_id = [5]\n    scenario.state = states.publishing_failed\n    scenario.save()\n    last_response = self.when_i_recover_scenario(scenario.pk)\n    assert_that(last_response.status_code, is_(404))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_with_booking__good(self) -> None:\n    booking = self.any_booking()\n    data = {\"reference\": booking.pk, \"quantity\": 1, \"item_type\": create_cart_item_types.booking}\n    form = CartItemCreateForm(data=data, cart=self.cart)\n    assert_that(form.is_valid(), is_(True))\n    form.add(user=self.any_user(secure_mode_version=secure_mode_versions.secure_mode_3ds2))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with an Essentielle panel\n        - a HssDriver\n    When:\n        - I list devices\n    Then:\n        - No error is raised\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_hm)\n    driver = driver_factory.get_driver(hss)\n    devices = driver.devices.list()\n    assert_that(devices, not_(empty()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form_other_invalid(self) -> None:\n    data = {\n        \"status\": \"456\",  # bad value\n    }\n\n    form = AlarmStatusConditionForm(data=data)\n\n    self.assertFalse(form.is_valid())\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_first_credits_pack_purchase_promo_code__welcome_code(self) -> None:\n    credits_pack_deal = self.any_deal(profile=deal_profiles.credits_pack)\n    cart = self.any_cart(deal=credits_pack_deal)\n    promo_code = self.any_promocode(\n        version=2,\n        profile=promocode_profiles.v2_first_credits_pack_purchase,\n        code=\"WELCOME\",\n    )\n    promocode_not_valid = promo_code.clean_promocode_validation_for_cart(cart)\n    assert_that(promo_code.valid_for_station, is_(none()))\n    assert_that(promocode_not_valid, is_(None))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_page__delegation_disabled(self) -> None:\n    delegation = self.any_delegation(enabled=False)\n    with self.assertRaises(Redirect) as e:\n        assert_that(InvitationPage.get(token=delegation.token))\n    response = e.exception.args[0]\n    assert_that(response.status_code, is_(302))\n    assert_that(response.url, reverse(\"www:error\", kwargs={\"token\": delegation.token}))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_client_raises_bad_tracker_on_climax_501(self) -> None:\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    client = Client(hss)\n    with requests_mock.Mocker() as m:\n        m.get(self._mock_endpoint, status_code=501)\n        assert_that(calling(client.request).with_args(self._mock_endpoint), raises(BadTracker))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_calendar__empty_string_body(self) -> None:\n    hss = self.any_configured_hss(account=opv_contact_45_account)\n    driver = driver_factory.get_driver(hss=hss)\n    with requests_mock.Mocker(real_http=True) as m:\n        m.get(\"https://domoweb-rec.imt.fm/applicationservice/domoweb/panel/calendar\", text=\"\", status_code=200)\n        assert_that(driver.scenarios._scenarios_calendar(), is_(empty()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serialize_transaction(self) -> None:\n    \"\"\"\n    Given : A transaction\n    When : I serialize this transaction\n    Then : I get a dict corresponding to the transaction i serialized\n    \"\"\"\n    hss = self.any_hss()\n    transaction = self.any_transaction(hss=hss)\n\n    serializer = TransactionSerializer(instance=transaction)\n    data = serializer.data\n    assert_that(data, has_entries({\"pk\": is_(transaction.pk), \"model\": \"hss.transaction\", \"fields\": not_none()}))\n    transaction_data = data[\"fields\"]\n    assert_that(\n        transaction_data,\n        has_entries(\n            {\n                \"state\": is_(transaction.state),\n                \"error_description\": is_(\"\"),\n                \"type\": is_(transaction.type),\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_delete_code_serializer(self) -> None:\n    \"\"\"\n    Given a hss with a code\n    Given delete code data\n    Given a hss delete code pending transaction\n    When I serialize data\n    Then no error\n    Then a code is delete\n    Then transaction is succeed\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.honeywell)\n    code = self.any_honeywell_code(hss=hss)\n\n    transaction = self.any_transaction(\n        hss=hss, type=transaction_types.delete_code, state=transaction_states.pending\n    )\n    data = {\"prom\": hss.prom_code, \"index\": code.index, \"label\": \"Tata\"}\n    serializer = EquipmentDeleteCodeEventSerializer(data=data)\n    serializer.is_valid(raise_exception=True)\n    serializer.process_event()\n    transaction.refresh_from_db()\n    assert_that(HoneywellCode.objects.filter(id=code.id).exists(), is_(False))\n    assert_that(transaction.state, is_(transaction_states.success))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__framed(self) -> None:\n    \"\"\"coverage test\"\"\"\n    for state in {\n        request_states.initial,\n        request_states.draft,\n        request_states.dropped,\n        request_states.tms_transmission,\n        # request_states.cancelling,\n        request_states.refused,\n        request_states.waiting,\n        request_states.planned,\n        request_states.in_progress,\n        request_states.completed,\n        request_states.aborted,\n        request_states.cancelled,\n        request_states.tms_shipment_refused,\n    }:\n        with self.subTest(state=state):\n            self.any_framed_request(state=state)\n            PartialRequestsPage.get(client=self.client, site_slug=self.client.sites[0].slug)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_create_scenarios(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario\n    When : I post this dict\n    Then : I get a 201 HTTP response, a dict with one scenario\n    \"\"\"\n    data = self.any_scenario_data(self.initial_scenario)\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(Scenario.objects.all(), has_length(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_valid__bypass_validation_rules(self) -> None:\n    request = self.any_request(state=request_states.draft, ready_to_submit=False)\n    data = self.any_step_form_data(steps=request.steps.all())\n    formset = make_step_formset_class(instance=request, user=request.creator, bypass_validation_rules=True)(\n        instance=request, data=data\n    )\n\n    assert_that(formset.is_valid(), is_(True), formset.errors)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cache_set_then_get_gives_value(self) -> None:\n    cache.set(\"test_cache_key\", \"my value\")\n    value = cache.get(\"test_cache_key\")\n\n    assert_that(value, is_(\"my value\"))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_client_raises_unavailable_on_climax_600(self) -> None:\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_hm)\n    client = Client(hss)\n    with requests_mock.Mocker() as m:\n        m.get(self._mock_endpoint, status_code=600)\n        assert_that(calling(client.request).with_args(self._mock_endpoint), raises(Unavailable))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_swap_step_pu__unicity(self) -> None:\n    \"\"\"\n    Given a request with 2 pu\n    When i add 2 step pu with same pu\n    Then it raise exception\n    \"\"\"\n    request = self.any_request(\n        state=request_states.initial, type=request_types.quoted, ready_to_submit=True, with_packaging_units=2\n    )\n    data = self.any_step_form_data(steps=request.steps.all())\n    pu_1 = data[\"steps-0-step_pu_formset-0-packaging_unit\"]\n    data[\"steps-0-step_pu_formset-1-packaging_unit\"] = pu_1\n    formset = make_step_formset_class(instance=request, user=request.creator)(instance=request, data=data)\n    assert_that(formset.is_valid(), is_(False))\n    assert_that(\n        formset.forms[0].nested.errors[1][\"__all__\"], has_item(\"Corrigez les valeurs en double ci-dessous.\")\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__valid(self) -> None:\n    climax_panel_cond_post_json = load(\"climax_panel_device_post_valid.json\")\n    serializer = UpdateResponseSerializer(data=climax_panel_cond_post_json)\n    serializer.is_valid(raise_exception=True)\n    assert_that(serializer.data[\"message\"], is_(\"OK\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_parse_action_power_switch__onduring(self) -> None:\n    contract = ContractMixin().any_climax_contract()\n    hss = HssMixin().any_hss(user=contract.user, contract=contract, remote_proxy=remote_proxies.climax_kiz)\n    parsed_action = Kiz3PadMobileParser().parse_action(\n        1, \"a=1&z=4&sw=on&pd=100\", hss.driver.scenarios.list_scenario_devices()\n    )\n    assert_that(parsed_action, instance_of(PowerSwitchActionClimax))\n    assert_that(parsed_action.status, is_(\"on\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_parse_action_panel_status__on(self) -> None:\n    contract = ContractMixin().any_climax_contract()\n    hss = HssMixin().any_hss(user=contract.user, contract=contract, remote_proxy=remote_proxies.climax_kiz)\n    parsed_action = Kiz3PadMobileParser().parse_action(1, \"a=1&m=1\", hss.driver.scenarios.list_scenario_devices())\n    assert_that(parsed_action, instance_of(PanelStatusActionClimax))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_anonymous(self) -> None:\n    self.client = AnonymousClient()\n    promocode = self.any_promocode()\n    cart = self.any_cart(state=cart_states.active, api_version=API_VERSION)\n    self.when_i_search_promocode(cart=cart, code=promocode.code)\n\n    assert_that(self.last_response, http(200))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__forbidden(self) -> None:\n    site = self.any_site()\n    user = self.any_user(roles=[permission_roles.third_party_operator], sites=[site.uuid])\n    self.client = AuthenticatedClient(user=user)\n    request = self.any_request()\n    with self.assertRaises(ForbiddenException):\n        RequestNotificationsPage.get(client=self.client, site_slug=site.slug, pk=request.pk)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_command(self) -> None:\n    \"\"\"\n    Given any site\n    When I call export_sites command\n    Then csv contains site\n    \"\"\"\n    site = self.any_site()\n    management.call_command(\"export_sites\")\n    with open(\"export_sites.csv\", \"rt\") as f:\n        lines = f.readlines()\n    lines.pop(0)\n    assert_that(\n        lines,\n        contains_exactly(f\"{site.uuid},{site.name},{site.raw['data']['description'] if site.raw else ''}\\n\"),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_myr_271__other_field_changed(self) -> None:\n    \"\"\"\n    Given\n        - two fields configuration\n            - One for shipping_type\n            - One for invoice_reference\n        - a request with not default shipping_type value\n    When I change invoice_reference configuration & duplicate the request\n    Then\n        - Value for shipping_type did not change\n        - Value for invoice_reference is the default value\n    \"\"\"\n    self.any_request_type_site_value(key=\"default-shipping-value\", conf=self.conf, is_default=True)\n    self.any_request_type_site_value(key=\"other-shipping-value\", conf=self.conf, is_default=False)\n\n    invoice_definition = Definition.objects.get(name=\"request.invoice_reference\")\n    invoice_conf = self.any_request_type_site_configuration(\n        definition=invoice_definition, site=self.site, request_type=self.request_type\n    )\n    value = self.any_request_type_site_value(key=\"default-invoice-value\", conf=invoice_conf, is_default=True)\n    request = self.any_framed_request(\n        site=self.site, creator=self.client.user, shipping_type=\"other-shipping-value\"\n    )\n    value.key = \"new-default-invoice-value\"\n    value.save()\n\n    with self.assertRaises(RedirectException) as e:\n        RequestActionPage.get(\n            client=self.client,\n            url=reverse(\n                \"www:request-action-duplicate\", kwargs={\"site_slug\": request.site.slug, \"pk\": request.uuid}\n            ),\n        )\n    assert_that(Request.objects.count(), is_(2))\n    duplicated_request_pk = e.exception.response.url.split(\"/\")[-2]\n    duplicated = Request.objects.get(pk=duplicated_request_pk)\n    assert_that(duplicated.shipping_type, is_(\"other-shipping-value\"))\n    assert_that(duplicated.invoice_reference, is_(\"new-default-invoice-value\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_scenario_status__device_json(self) -> None:\n    scenario = HoneywellScenarioStatus(driver=self.driver, identifier=\"test\", name=\"name\")\n    option_value = \"option_value\"\n    returned_dict, identifier = scenario._device_json(option_value=option_value)\n    assert_that(\n        returned_dict,\n        is_(\n            {\n                \"attributes\": {\"attributes\": [{\"name\": scenario_attributes.serial, \"value\": scenario.identifier}]},\n                \"scenarios\": scenario._scenario_json(scenario.name, option_value),\n            }\n        ),\n    )\n    assert_that(scenario.identifier, is_(identifier))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter_shipping_markup_framed(self) -> None:\n    \"\"\"\n    Given a request\n    When I use RequestFormatter with 'shipping_markup' field to export\n    Then it return a dict that contain request shipping_markup\n    \"\"\"\n    site = self.any_site(with_markup=True)\n    request = self.any_framed_request(site=site)\n    request_csv = RequestFormatter().to_csv(request, fields=[\"shipping_markup\"])\n    assert_that(request_csv[0], is_(empty()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_icon__valid(self) -> None:\n    \"\"\"\n    Given\n        - a Hss with ClimaxKiz panel\n        - a HssDriver\n        - a climax powerswitch\n    When\n        - I update powerswitch icon\n    Then\n        - I get an updated powerswitch\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    driver = driver_factory.get_driver(hss)\n    climax_powerswitch = self.any_climax_powerswitch(hss=hss)\n    updated_climax_powerswitch = driver.power_switches.update_icon(\n        device_id=climax_powerswitch.zigbee_id, new_icon=power_switch_icons.iron\n    )\n    assert_that(updated_climax_powerswitch.icon, is_(power_switch_icons.iron))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_name(self) -> None:\n    \"\"\"\n    Given\n        - a Hss with a honeywell panel\n        - a HssDriver\n        - a honeywell powerswitch\n    When\n        - I update powerswitch name\n    Then\n        - I get an updated powerswitch\n    \"\"\"\n    hss = self.any_configured_hss(account=default_honeywell_account)\n    driver = driver_factory.get_driver(hss)\n    honeywell_powerswitch = self.any_honeywell_powerswitch(hss=hss)\n    new_name = get_random_string(8)\n    updated_honeywell_powerswitch = driver.power_switches.update_name(\n        device_id=str(honeywell_powerswitch.id), new_name=new_name\n    )\n    honeywell_powerswitch.refresh_from_db()\n    assert_that(updated_honeywell_powerswitch.name, is_(new_name))\n    assert_that(honeywell_powerswitch.name, is_(updated_honeywell_powerswitch.name))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_user_needs_notify__dont_allow_crm(self) -> None:\n    \"\"\"\n    Given a registered user with one order sold and with push token\n          an active notifier\n    When refreshing notifier\n    Then notifier is still in inactive state\n    \"\"\"\n    zone_context = ZoneContextMixin().any_zone_context()\n    user = self.any_user(mangopay_card=mangopay_cards.normal)\n    self.client = AuthenticatedClient(user=user)\n    self.any_order_sold(zone_context=zone_context)\n    reminder = user.occasional_buyer_notifier_set.first()\n    reminder.refresh_from_db()\n    reminder.state = occasional_buyer_notifier_states.needs_notify\n    reminder.save()\n    user.allow_crm = False\n    user.save()\n    launch_all_occasional_buyer_notifier()\n    reminder.refresh_from_db()\n    assert_that(reminder.state, is_(occasional_buyer_notifier_states.inactive))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_resynchro_task__already_in_progress(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.post(url, data={\"contract_number\": hss.site.contract.contract_number})\n    assert_that(response.status_code, is_(409), response.content)\n    assert_that(ResynchroTask.objects.count(), is_(1))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_uri_properties(self) -> None:\n    \"\"\"\n    Given any file uri\n    When getting properties\n    Then we have expected values\n    \"\"\"\n    uri = FileUri(\"file://hostname/path/to/specific/file.txt\")\n    assert_that(\n        uri,\n        has_properties(\n            {\n                \"hostname\": is_(\"hostname\"),\n                \"value\": is_(\"file://hostname/path/to/specific/file.txt\"),\n                \"path\": is_(\"/path/to/specific/file.txt\"),\n                \"name\": is_(\"path/to/specific/file.txt\"),\n            }\n        ),\n    )\n    assert_that(str(uri), is_(\"FileUri(file://hostname/path/to/specific/file.txt)\"))\n    assert_that(hash(uri), uri._value)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_set_faststatus_valid_group(self) -> None:\n    redis_client = FastStatusRedisClient([\"test_key\"])\n    faststatus = FastStatus(\n        identifier=\"test_key\",\n        source=sources.application_set_status,\n        timestamp=int(time.time() * 10e5),\n        raw_status=\"on\",\n        group=1,\n    )\n    redis_client.set_fast_status(faststatus)\n    cached_faststatus = redis_client.get_fast_status()\n    assert_that(cached_faststatus, is_(not_none()))\n    assert_that(cached_faststatus.group, is_(faststatus.group))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__list(self) -> None:\n    \"\"\"\n    Given :\n            - any hss\n            - 2 honeywell codes associated to this hss\n            - data corresponding to one of this code\n    When I serialize it\n    Then only the serialize code is in database\n    \"\"\"\n    hss = self.any_hss()\n    code1 = self.any_honeywell_code(hss=hss)\n    code2 = self.any_honeywell_code(hss=hss)\n    data = [{\"id\": code1.index, \"keypadCode\": code1.code, \"label\": \"label1\", \"zone\": 1, \"isEnabled\": True}]\n    serializer = CodeSerializer(data=data, many=True)\n    serializer.is_valid(raise_exception=True)\n    codes = serializer.list(hss)\n    code1.refresh_from_db()\n    assert_that(codes, not_(empty()))\n    assert_that(code1.label, is_(\"label1\"))\n    assert_that(Code.objects.filter(pk=code2.pk).exists(), is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenarios_maia__device_not_found(self) -> None:\n    \"\"\"\n    Given a client with contract supporting 'connected home'\n    Given a scenario Maia with action device not found (for device and site id)\n    When I list scenario\n    Then 200\n    Then I have no scenario\n    \"\"\"\n    self.client.hss.site.contract.capabilities.append(ContractCapabilities.connected_home.value)\n\n    self.client.hss.site.contract.save()\n    self.any_maia_scenario(hss=self.client.hss)\n\n    device = self.any_local_device(type=DeviceType.heater)\n    device.maia_device_id = \"wrong_device_id\"\n    device.maia_site_id = \"wrong_site_id\"\n    device.save()\n\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(0))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_scenarios(self) -> None:\n    \"\"\"\n    Given : A scenario with two actions\n            A new dict representing this scenario with only one action\n    When : I put this dict\n    Then : I get a 200 HTTP response, a dict representing the scenario with only one action\n    \"\"\"\n    action = self.initial_scenario.info.actions[0]\n    new_scenario_info = ScenarioInfo(\n        condition=self.initial_scenario.info.condition,\n        actions=[\n            action,\n        ],\n        remote_proxy=self.driver.hss.remote_proxy,\n    )\n    self.initial_scenario.info = new_scenario_info\n    data = self.any_scenario_data(self.initial_scenario)\n    self.initial_scenario.scenario_type.action_type.append(ActionType.CHANGE_PANEL_STATUS_ON)\n    self.initial_scenario.scenario_type.save()\n    last_response = self.when_i_update_scenario(data, self.initial_scenario.pk)\n    assert_that(last_response.status_code, is_(200), last_response.content)\n    assert_that(last_response.json(), is_(not_none()))\n    assert_that(last_response.json(), has_entry(\"fields\", not_none()))\n    fields = last_response.json()[\"fields\"]\n    assert_that(fields, has_entry(\"actions\", not_none()))\n    assert_that(fields[\"actions\"], has_length(1))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_form_off_valid_without_zone(self) -> None:\n    data = {\n        \"area\": \"1\",\n        \"zone\": None,\n    }\n\n    form = CreateCameraActionForm(data=data)\n    is_valid = form.is_valid()\n\n    self.assertTrue(is_valid)\n    self.assertEqual(form.to_grammar(), \"a=1&req=img_all\")\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_properties(self) -> None:\n    pu = self.any_packaging_unit()\n    assert_that(str(pu), anything())\n    assert_that(pu.uri, is_(Uri(f\"myroad://request/{str(pu.request_id)}/packaging_unit/{pu.identifier}\")))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_without_master_scenario(self) -> None:\n    \"\"\"\n    Given a master scenario with climax and maia scenario\n    Given a master scenario with only a climax scenario\n    When I list scenario\n    Then 200\n    Then 2 scenario data\n    \"\"\"\n    hss = self.any_hss()\n    ScenarioMixin().any_scenario(hss=hss)\n    last_response = self.when_i_list_scenarios(hss_pk=hss.pk)\n\n    assert_that(last_response.status_code, is_(200))\n    assert_that(last_response.json(), has_length(1))\n    assert_that(last_response.json(), has_items(scenario_pmf_data()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form_update_billing_unit_type(self) -> None:\n    \"\"\"\n    Given any request without carriage and with a billing unit type = \"f\"\n    When I add one with reservation type as day\n    Then request billing unit type is \"j\"\n    \"\"\"\n\n    request = self.any_request(\n        state=request_states.draft,\n        ready_to_submit=True,\n        with_packaging_units=False,\n        with_carriages=False,\n        with_step_units=False,\n    )\n\n    assert request.billing_unit_type == billing_unit_types.flat_rate\n\n    self.any_carriage(request=request, type=carriage_types.day)\n    data, files = self.any_carriage_form_data(carriages=request.carriages.all())\n\n    formset = make_carriage_formset_class(instance=request, user=request.creator)(\n        instance=request, data=data, files=files\n    )\n    formset.save()\n\n    assert_that(request.billing_unit_type, is_(billing_unit_types.day))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list__paginated(self) -> None:\n    \"\"\"\n    Given 25 archived deliveries\n    When I list\n    Then :\n        - 200 OK\n        - the results is correctly paginated\n    \"\"\"\n    self.client = AuthenticatedClient()\n\n    for _ in range(25):\n        order = self.any_order(user=self.client.user, api_version=API_VERSION)\n        self.any_delivery(\n            order=order,\n            api_version=API_VERSION,\n            rating_level=delivery_rating_level.high,\n        )\n\n    self.when_i_list_deliveries_archived()\n\n    assert_that(len(self.last_response.json()[\"results\"]), is_(20))\n    assert_that(self.last_response.json()[\"previous\"], is_(none()))\n    assert_that(self.last_response.json()[\"next\"], is_not(none()))\n    assert_that(self.last_response, http(200))\n\n    response = self.client.get(self.last_response.json()[\"next\"])\n\n    assert_that(len(response.json()[\"results\"]), is_(5))\n    assert_that(response.json()[\"previous\"], is_not(none()))\n    assert_that(response.json()[\"next\"], is_(none()))\n    assert_that(response, http(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_type_universe__no_matching_scenario_type_universe(self) -> None:\n    \"\"\"\n    Given : 4 scenarios type universe with target == 'pad_web'\n    When : I list scenario type unive\n    Then : Http response is 200, response contain 0 Scenario Type universe with target == 'pad_mobile'\n    \"\"\"\n    ScenarioTypeUniverse.objects.filter(target=targets.pad_mobile).delete()\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(0))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(ALLOW_SEND_EMAIL=True)\ndef test_send_customer_service_email__without_date(self) -> None:\n    self.client = AuthenticatedClient()\n\n    self.when_i_send_customer_service_data(with_date=False)\n    assert_that(self.last_response.status_code, is_(200))\n    assert_that(self.last_response.json().get(\"status\"), is_(\"Votre message a bien été envoyé.\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_hss_rating_config(self) -> None:\n    hss = self.client.hss\n\n    hss_rating_config = HssRatingConfigBuilder(hss=hss).get_config()\n\n    assert_that(hss_rating_config.enabled, is_(not_none()))\n    rating_config = hss_rating_config.rating_config\n    assert_that(rating_config, is_(not_none()))\n    assert_that(rating_config.min_connection_per_week, is_(not_none()))\n    assert_that(rating_config.is_later_option_enabled, is_(not_none()))\n    assert_that(rating_config.later_option_postpone_duration, is_(not_none()))\n    assert_that(rating_config.display_delay_duration, is_(not_none()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_models__update_request_filter_model_advanced(self) -> None:\n    \"\"\"\n    Given:\n        - any site\n        - 2 users\n        - 2 teams on same site associate to the 2 users\n        - 2 filters (RequestFilterModel) associated to respectively the first and the second user\n        - any event team_users_changed event on filtered teams that remove user1 from team1\n    When I load event\n    Then filter (RequestFilterModel) teams are updated :\n        - The filter1 contains the teams2\n        - The filter2 contains the team1 and the team2\n    \"\"\"\n    site = self.any_site()\n    user1 = self.any_user(sites=[site.uuid])\n    user2 = self.any_user(sites=[site.uuid])\n    user3 = self.any_user(sites=[site.uuid])\n    team1 = self.any_team(site=site, with_users=[user1, user2, user3], name=\"team1\")\n    team2 = self.any_team(site=site, with_users=[user1, user2, user3], name=\"team2\")\n    filter1 = self.any_request_filter(creator=user1, with_teams=[team1, team2])\n    filter2 = self.any_request_filter(creator=user2, with_teams=[team1, team2])\n    filter3 = self.any_request_filter(creator=user3, with_teams=[team1, team2])\n    event = self.any_users_changed_event(team=team1, with_users=[user2, user3])\n    UsersChangedEventLoader().as_instance(message=event)\n    filter1.refresh_from_db()\n    filter2.refresh_from_db()\n    assert_that(filter1.teams, only_contains(*[str(team2.uuid)]))\n    assert_that(filter2.teams, only_contains(*[str(team1.uuid), str(team2.uuid)]))\n    assert_that(filter3.teams, only_contains(*[str(team1.uuid), str(team2.uuid)]))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@unittest.skip(\"Impossible to have that use case by design ! Should be delete ?\")\ndef test_no_step_pu(self) -> None:  # pragma: no cover # noqa: RMS201\n    \"\"\"\n    When submit form without step pu\n    Then an alert must be shown\n    \"\"\"\n    request = self.any_quoted_request(state=request_states.initial, creator=self.client.user)\n    [step.step_packaging_units.all().delete() for step in request.steps.all()]\n    with self.assertRaises(RequestActionPage.RequestForm.Error) as em:\n        RequestActionPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk).form.submit()\n    assert_that(em.exception.soup.find(\"button\", attrs={\"id\": \"update-steps-error-alert-button\"}), not_none())\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_change_power_switch_icon(self) -> None:\n    power_switch_data = self.when_i_list_power_switches_for_hss(self.client.hss)[0]\n    new_icon = \"light\" if power_switch_data[\"fields\"][\"icon\"] == \"toy\" else \"toy\"\n\n    self.when_i_update_power_switch_icon(self.client.hss.pk, power_switch_data[\"pk\"], new_icon)\n\n    assert_that(self.last_response.status_code, is_(status.HTTP_204_NO_CONTENT))\n    self.then_power_switch_icon_is(self.client.hss, power_switch_data[\"pk\"], new_icon)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update(self) -> None:\n    \"\"\"\n    Given\n        - a Hss for ClimaxKiz panel\n        - a HssDriver\n        - an existing code\n        - data to update this code\n    When\n        - I update this code\n    Then\n        - I get the updated code\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    driver = driver_factory.get_driver(hss)\n    code = self.any_code(hss=hss)\n    new_code = get_random_string(length=4, allowed_chars=(\"1234567890\"))\n    data = {\n        \"master_code\": \"1001\",\n        \"code\": new_code,\n        \"name\": \"Test update name\",\n    }\n    updated_code = driver.codes.update(code_pk=code.pk, data=data)\n\n    assert_that(updated_code.name, is_(\"Test update name\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_read__not_found(self) -> None:\n    self.client = AnonymousClient()\n\n    self.when_i_read_station(station_pk=1234)\n\n    assert_that(self.last_response, http(404))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_activate_unexisting_scenario(self) -> None:\n    \"\"\"\n    Given a unexisting scenario in maia\n    When I try to activate it\n    Then NotFound\n    \"\"\"\n    assert_that(\n        calling(self.maia_scenario_driver.activate_scenario).with_args(\n            scenario=MaiaScenario(\n                uuid=UUID(\"2eb28e47-6794-4f01-a5c8-541e2258fe76\"),\n                mirror_scenario_uuid=UUID(\"2eb28e47-6794-4f01-a5c8-541e2258fe76\"),\n            ),\n        ),\n        raises(NotFound),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promotional_offer_free_multiple(self) -> None:\n    \"\"\"\n    Given a station with promotional offer for a free item\n    When I add two required items to cart\n    Then two free items are added automatically\n    \"\"\"\n    cart = self.any_cart()\n    promotional_offer = self.promotional_offer_free\n    station = self.station\n    required_deal, _ = promotional_offer.get_deals_for_station(station)\n    required_deal = required_deal[0]\n    self.add_item(cart, required_deal, quantity=2)\n\n    assert_that(cart.cartitem_set.count(), is_(2))\n    for cart_item in cart.cartitem_set.all():\n        assert_that(cart_item.quantity, is_(2))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_waiting__to_completed(self) -> None:\n    \"\"\"\n    Given a shipping record in waiting state\n    When i received completed state changed event\n    Then request is completed\n    \"\"\"\n    sr = self.any_shipping_record()\n\n    data = self.any_shipping_record_state_changed_data(shipping_record=sr, state=shipping_record_states.completed)\n    loader = ShippingRecordStateChangedLoader()\n    event = loader.on_message(\"\", data)\n    assert event\n    sr.refresh_from_db()\n    assert_that(sr.request.state, is_(request_states.completed))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update__raises_bad_response_error_from_error_code(self) -> None:\n    \"\"\"\n    Given:\n        - an Hss with Honeywell panel\n        - a HssDriver\n        - a status set to on\n    When:\n        - I update status\n        - I mock the serializer that generates a read_error_code != 0\n    Then:\n        - I get an BadResponse exception\n    \"\"\"\n    hss = self.any_configured_hss(account=default_honeywell_account)\n    driver = driver_factory.get_driver(hss=hss)\n\n    def read_error_code() -> int:\n        return 1\n\n    with mock.patch.object(  # noqa: RMS102\n        UpdateResponseSerializer, \"read_error_code\", side_effect=read_error_code\n    ):\n        with self.assertRaises(BadResponse):\n            driver.status.update(new_status=HssStatus.OFF, code=\"1001\")\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cancel__to_cancelled(self) -> None:\n    \"\"\"\n    Given a request without shipping record\n    When i cancel\n    Then request is in cancelled state\n    \"\"\"\n    for state in {request_states.refused, request_states.tms_transmission}:\n        with self.subTest(state=state):\n            request = self.any_framed_request(state=state)\n            request.state_machine(user=request.creator).cancel(comment=\"toto\")\n            assert_that(request.state, is_(request_states.cancelled))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_repository(self) -> None:\n    \"\"\"\n    Given 1 zone_context and 1 checkout associated with this zone_context\n    When I call the repository\n    Then I get 1 checkout\n    \"\"\"\n    zone_context = self.any_zone_context()\n    self.any_checkout(state=checkout_states.ready, zone_context=zone_context)\n\n    filtered = CheckoutRepository().get_all(zone_context)\n\n    assert_that(len(filtered), is_(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_change_ir_detector_name(self) -> None:\n    ir_detectors = self.when_i_list_ir_detectors_for_hss(self.client.hss)\n    self.when_i_change_ir_detector_name(self.client.hss, ir_detectors[0][\"pk\"])\n    assert_that(self.last_response.status_code, is_(status.HTTP_204_NO_CONTENT))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_name_not_implemented(self) -> None:\n    hss = self.any_hss()\n    driver = CameraDriver(hss)\n    with self.assertRaises(NotImplementedError):\n        driver.update_name(camera_id=0, new_name=\"\")\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list__invalid_response_json(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with ClimaxKiz panel\n        - a HssDriver\n    When:\n        - I list events which returns an invalid json\n    Then:\n        - I get a BadResponse\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_hm)\n    driver = driver_factory.get_driver(hss)\n    with mock.patch.object(ListResponseSerializer, \"is_valid\", side_effect=ValidationError):  # noqa: RMS102\n        assert_that(calling(driver.events.list).with_args(limit=4), raises(BadResponse))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_vehicle_models_is_frauder_by_admin(self) -> None:\n    self.client = AuthenticatedClient()\n    self.client.user.is_frauder = True\n    self.client.user.frauder_reason = frauder_reasons.by_admin\n    self.client.user.last_frauder_update = timezone.now()\n    vehicle_model = self.any_vehicle_model()\n    self.when_i_list_vehicle_model(brand_pk=vehicle_model.vehicle_brand.pk)\n\n    assert_that(self.last_response, http(403))\n    assert_that(\n        self.last_response.json(),\n        has_entry(\n            \"detail\",\n            \"\"\"Par mesure de sécurité, votre compte a été suspendu. \\nSi vous souhaitez le réactiver, vous pouvez nous contacter via la rubrique “A propos” > “Aide et suggestions” de l’application.\"\"\",  # noqa\",\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_change_power_switch_icon(self) -> None:\n    power_switch_data = self.when_i_list_power_switches_for_hss(self.client.hss)[0]\n    new_icon = \"light\" if power_switch_data[\"fields\"][\"icon\"] == \"toy\" else \"toy\"\n\n    self.when_i_update_power_switch_icon(self.client.hss.pk, power_switch_data[\"pk\"], new_icon)\n\n    assert_that(self.last_response.status_code, is_(status.HTTP_204_NO_CONTENT))\n    self.then_power_switch_icon_is(self.client.hss, power_switch_data[\"pk\"], new_icon)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_expired_transaction(self) -> None:\n    \"\"\"\n    Given a hss\n    Given a pending transaction that is expired and a pending transaction that is not expired\n    When I call the expired property\n    Then the return queryset only contains the expired transaction\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    hss2 = self.any_hss(remote_proxy=remote_proxies.honeywell)\n    _5mn_ago = timezone.now() - timedelta(minutes=5)\n    with mock.patch.object(timezone, \"now\", return_value=_5mn_ago):  # noqa: RMS102\n        transaction = self.any_transaction(hss=hss, state=transaction_states.pending)\n    self.any_transaction(hss=hss2, state=transaction_states.pending, type=transaction_types.update_code)\n    exp_transactions = Transaction.objects.expired\n    assert_that(exp_transactions, only_contains(transaction))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_consumer__cancellation__contract_number(self) -> None:\n    broker_url = settings.IMA_BROKER_URL_CRM\n    cancellation_queue = queues.cancellation\n\n    self.generate_change(broker_url=broker_url, queue=cancellation_queue, body={\"contract_numbers\": \"20160431006\"})\n\n    event = self.consume_event(broker_url=broker_url, event=events.cancellation, queue=cancellation_queue)\n\n    assert_that(event, has_property(\"state\", event_states.pending))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_enforce_timezone(self) -> None:\n    dt1 = timezone.now()\n    dt2 = timezone.now()\n\n    field = DSTCompatibleDateTimeField(dt1)\n\n    def test(*args, **kwargs):\n        raise ValidationError()\n\n    with mock.patch(\"rest_framework.serializers.DateTimeField.enforce_timezone\", side_effect=test):  # noqa: RMS102\n        with self.assertRaises(ValidationError):\n            field.enforce_timezone(value=dt2)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_brand_serializer(self) -> None:\n    autowash = load(\"autowash.json\")\n    data = autowash[\"data\"][\"brand\"]\n\n    serializer = BrandSerializer(data=data)\n    serializer.is_valid(raise_exception=True)\n\n    assert_that(\n        serializer.validated_data,\n        has_entries(\n            {\n                \"identifier\": is_(uuid.UUID(data[\"identifier\"])),\n                \"name\": is_(data[\"name\"]),\n                \"logo\": is_(data[\"logo\"]),\n                \"zone_context\": is_(data[\"zone_context\"]),\n            }\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__pickup_address_street__no_steps(self) -> None:\n    \"\"\"\n    Given a request without request\n    When I use RequestFormatter with 'pickup_address_street' field to export\n    Then it return a dict that contain request pickup address street 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_address_street\"])\n    assert_that(request_csv[0], is_(\"\"))\n", "output": "3"}
{"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_update_scenarios__incorrect_scenario_pk(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario with new data\n    When : I put this dict to an url containing a scenario_pk wich not exist\n    Then : I get a 404 HTTP response\n    \"\"\"\n    hss = self.client.hss\n    scenario = self.any_scenario(hss=hss)\n    data = self.any_scenario_data(scenario)\n    last_response = self.when_i_update_scenario(data, scenario_pk=1234)\n    assert_that(last_response.status_code, is_(404), last_response.content)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_type_universe__no_scenario_type_univers(self) -> None:\n    \"\"\"\n    Given : 0 inital scenarios type universe\n    When : I list scenario type universe\n    Then : Http response is 200, response contain 0 Scenario Type\n    \"\"\"\n    ScenarioTypeUniverse.objects.all().delete()\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(0))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update(self) -> None:\n    \"\"\"\n    Given:\n        - an user loader\n        - an user\n        - a json from bus related to this user updated\n    When load json\n    Then user is updated\n    \"\"\"\n    loader = KleenUserLoader()\n    json = load(\"user.json\")\n    key = json[\"uri\"].split(\"/\")[-1]\n    user = loader.on_message(\"resource.kleen.user\", json, key)\n\n    assert_that(user, user_matcher(first_name=\"support\"))\n\n    json[\"data\"][\"given_name\"] = \"Updated Name\"\n    loader.on_message(\"resource.kleen.user\", json, key)\n    assert user, \"Should not be null\"\n    user.refresh_from_db()\n    assert_that(user, user_matcher(first_name=\"Updated Name\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_user_vehicle(self) -> None:\n    \"\"\"\n    Given a client authenticated with a user which have a vehicle\n    When i update the vehicle of this user\n    Then i get a response with an http_status_code 200, the vehicle is updated\n    \"\"\"\n    self.client = AuthenticatedClient()\n    user_vehicle = self.any_user_vehicle(user=self.client.user)\n    new_vehicle_model = self.any_vehicle_model()\n    new_vehicle_registration = \"AA-AAA-AA\"\n    new_segment = segment_type.segment_large\n    new_description = \"test description updated\"\n    data = {\n        \"vehicle_model\": new_vehicle_model.pk,\n        \"vehicle_registration\": new_vehicle_registration,\n        \"segment\": new_segment,\n        \"description\": new_description,\n    }\n    self.when_i_update_user_vehicle(user_vehicle=user_vehicle, data=data)\n    assert_that(self.last_response.status_code, is_(200))\n    user_vehicle.refresh_from_db()\n    assert_that(user_vehicle.vehicle_registration, is_(new_vehicle_registration))\n    assert_that(user_vehicle.segment, is_(new_segment))\n    assert_that(user_vehicle.description, is_(new_description))\n    assert_that(user_vehicle.vehicle_model, is_(new_vehicle_model))\n    assert_that(user_vehicle.vehicle_model.vehicle_brand, is_(new_vehicle_model.vehicle_brand))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_attachments__known_attachment(self) -> None:\n    \"\"\"\n    Given any existing attachment with file\n    When I valid and save formset with form data for the same attachment file\n    Then attachment is updated\n    \"\"\"\n    request = self.any_request(state=\"draft\", ready_to_submit=False)\n    attachment = self.any_attachment(user=request.creator)\n    attachment_file = self.any_attachment_file(user=request.creator)\n    attachment.file = attachment_file\n    attachment.save()\n    formset = make_attachments_formset(instance=request, user=request.creator, read_only=False)(\n        data={\n            \"attachments-TOTAL_FORMS\": 1,\n            \"attachments-INITIAL_FORMS\": 0,\n            \"attachments-MIN_NUM_FORMS\": 0,\n            \"attachments-MAX_NUM_FORMS\": 1000,\n            \"attachments-0-description\": \"test\",\n            \"attachments-0-file\": attachment_file.pk,\n        },\n        form_kwargs={\"user\": request.creator},\n    )\n    assert_that(formset.is_valid(), is_(True))\n    formset.save()\n    assert_that(request.attachments.all(), has_length(1))\n    assert_that(request.attachments.first().pk, is_(attachment.pk))\n    attachment.refresh_from_db()\n    assert_that(attachment.description, is_(\"test\"))\n    assert_that(attachment.file, is_(attachment_file))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promo_code_valid_for_a_certain_amount_of_uses(self) -> None:\n    \"\"\"\n    Given : Any Cart with promocode rule valid_for_a_specific_amount_of_uses and a usage limit of 2\n    When : I do the checkout\n    Then : It succeeds\n    \"\"\"\n    user = self.any_user(mangopay_card=\"normal\")\n    cart = self.any_cart(\n        user=user,\n        deal=self.washing_deal,\n        state=cart_states.active,\n        profile=cart_profiles.deal_washing,\n    )\n    promo_code = self.any_promocode(\n        version=2,\n        profile=promocode_profiles.v2_cart_discount_percentage,\n        valid_for_washing_program=self.washing_deal.washing_program,\n    )\n    promo_code.usage_limit = 2\n    promo_code.rules.append(promo_code_rules.valid_for_a_specific_amount_of_uses)\n    promo_code.save()\n    cart.update(promocode=promo_code)\n    self.any_checkout(\n        cart=cart,\n        state=checkout_states.ordered,\n        payment_method=payment_methods.mangopay,\n        api_version=CURRENT_API_VERSION,\n        with_ip_address=True,\n        with_browser_info=True,\n    )\n    assert cart.promocode\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_mit_payerror(self) -> None:\n    \"\"\"\n    Given : ANy user with mp account and card secure but wrong secure mode return url\n    When : I subscribe and i realize first payment\n    Then : Registration is created but first payment invalid (exception raised)\n    \"\"\"\n    user = self.any_user(with_mp_user=True, mangopay_card=mangopay_cards.secure)\n    su = self.any_user_subscription(state=UserSubscriptionState.NEED_MIT_PAYMENT, user_=user)\n    registration = su.mangopay_registration\n    assert_that(registration.mangopay_recurring_payin_registration_id, not_none())\n    with override_settings(SECURE_MODE_RETURN_URL=\"bbbb\"):\n        with self.assertRaises(Exception):\n            su.start_mit_payment()\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_detail(self) -> None:\n    station = self.any_station()\n    self.when_i_view_instance_details(station)\n    assert_that(self.last_response.status_code, is_(200))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_str(self) -> None:\n    event_display_rule = EventDisplayRule.objects.create(event_code=9999, language=\"fr\", equipment_brand=\"climax\")\n    assert_that(\n        str(event_display_rule),\n        is_(\n            f\"Regle d'affichage des alarmes [{event_display_rule.event_code}, {event_display_rule.language}\"\n            f\", {event_display_rule.equipment_brand}]\"\n        ),\n    )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promo_code_discountlimited(self) -> None:\n    \"\"\"\n    Given : Given a promo code that give a percentage of 20%\n    When : I validate promocode on cart with a rule on discount limit of 1 euro and a total price of 8 euros\n    Then : the limit is encountered so the promocode price is equal to the discount limit\n    \"\"\"\n    cart = self.any_cart(\n        deal=self.washing_deal,\n        state=cart_states.active,\n        profile=cart_profiles.deal_washing,\n    )\n    promo_code = self.any_promocode(\n        version=2,\n        profile=promocode_profiles.v2_cart_discount_percentage,\n        valid_for_washing_program=self.washing_deal.washing_program,\n    )\n    promo_code.discount_limit = 1\n    promo_code.rules.append(promo_code_rules.valid_for_a_certain_ammount)\n    promo_code.save()\n    cart.update(promocode=promo_code)\n    checkout = self.any_checkout(\n        cart=cart,\n        state=checkout_states.ordered,\n        payment_method=payment_methods.dummy,\n        api_version=CURRENT_API_VERSION,\n        with_ip_address=True,\n        with_browser_info=True,\n    )\n    order = checkout.order\n    assert cart.promocode\n    assert_that(int(order.promocode_used_price), equal_to(cart.promocode.discount_limit))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list__invalid_response_json(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with an Essentielle panel\n        - a HssDriver\n    When:\n        - I list thermometers with an invalid json response\n    Then:\n        - I get a BadResponse exception\n    \"\"\"\n    hss = self.any_configured_hss(account=papillon_essentielle_account)\n    driver = driver_factory.get_driver(hss)\n\n    def invalid_json():\n        return {}\n\n    with mock.patch(\"requests.Response.json\", side_effect=invalid_json):  # noqa: RMS102\n        with self.assertRaises(BadResponse):\n            driver.thermometers.list()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_any_remote_connection_connecting(self) -> None:\n    \"\"\"\n    Given any remote connection with connecting args\n    Then I have connecting connection\n    \"\"\"\n    connection = self.any_remote_connection(state=ConnectionState.connecting)\n    assert_that(connection.state, is_(ConnectionState.connecting))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form_errors__actions__packing_missing(self) -> None:\n    request = self.any_request(type=request_types.quoted, state=request_states.draft, ready_to_submit=True)\n    pu = request.packaging_units.get()\n    pu.packing = \"\"\n    pu.save()\n    data, _ = self.any_packaging_unit_form_data(\n        packaging_units=request.packaging_units.all(), prefix=\"packaging_units\"\n    )\n    for action in [\"save\", \"add_um\", \"add_step\", \"validate\", \"submit\"]:\n        with self.subTest(action=action):\n            formset = make_pu_formset_class(instance=request, user=request.creator, action=action)(\n                instance=request, data=data\n            )\n\n            assert_that(formset.is_valid(), is_(False))\n            assert_that(formset.errors, contains_exactly(has_entry(\"packing\", not_(empty()))))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_empty(self) -> None:\n    expired_time = timezone.now() - 2 * Cart.EMPTY_CART_EXPIRATION\n    with freeze_time(expired_time, tick=True):\n        cart = self.any_cart(state=cart_states.empty)\n\n    cart.expire_if_needed()\n\n    assert_that(cart.state, is_(cart_states.expired))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_historical_acs_trans_called(self) -> None:\n    \"\"\"\n    Given any shipping record\n    When I receive acs trans called event for this shipping record\n    Then I get a new historical record for that request with corresponding ACS Trans data\n    \"\"\"\n    sr = self.any_shipping_record()\n    data = self.any_shipping_record_acs_trans_called_data(shipping_record=sr)\n    ShippingRecordACSTransCalledEventLoader().on_message(\"\", data)\n    assert_that(\n        HistoricalRecord.objects.filter(\n            request=sr.request,\n            triggered_by=HistoricalRecordTriggeredBy.ACS_TRANS,\n            type=HistoricalRecordType.API_UPDATE,\n        ),\n        has_length(1),\n    )\n    record = HistoricalRecord.objects.get(\n        request=sr.request,\n        triggered_by=HistoricalRecordTriggeredBy.ACS_TRANS,\n        type=HistoricalRecordType.API_UPDATE,\n    )\n    assert_that(record.data, has_entries({\"data\": instance_of(str), \"error\": is_(none())}))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_refresh_event_serializer_0039911(self) -> None:\n    \"\"\"\n    Given a user with a contract without hss\n    When refresh event\n    Then no error\n    \"\"\"\n    user = self.any_user(email=\"digitaltikiz3@yopmail.com\", password=\"123456\", subscriber_id=\"9201733248104\")\n    serializer = RefreshEventSerializer(data={\"subscriber_id\": user.source_id})\n    serializer.is_valid(raise_exception=True)\n    assert_that(serializer.validated_data, has_entry(\"users\", [user]))\n    serializer.process_event()\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_str(self) -> None:\n    zc = self.any_zone_context()\n    assert_that(str(zc), is_(f\"{zc.slug} | {zc.name}\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_checkout__pending__to_missing_browser_info(self) -> None:\n    \"\"\"\n    Given:\n        - a user\n        - a cart with this user\n        - a checkout\n    When: I refresh checkout\n    Then: Checkout is in missing_ip_address\n    \"\"\"\n    user = self.any_user(with_mobile_phone_verified=False)\n    cart = self.any_cart(user=user, state=cart_states.active)\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=None,\n    )\n    checkout.refresh(consumer=checkout.cart.user.consumer_set.first())\n\n    assert_that(checkout.state, equal_to(checkout_states.missing_browser_info))\n    assert_that(checkout.order_id, none())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_on_save(self) -> None:\n    offer = self.any_promotional_offer()\n\n    with mock.patch(  # noqa: RMS102\n        \"kleen.promotional_offers.update_handler\" \".PromotionalOfferUpdateHandler._run_update_tasks\"\n    ) as m:\n        offer.save()\n\n    m.assert_called_once()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_check__is_frauder_by_admin(self) -> None:\n    \"\"\"\n    Given a registered frauder user with a reset password validation code\n    When i check mobile phone with a code\n    Then there is a 403 response\n    \"\"\"\n    user = self.any_user(with_mobile_phone_verified=False)\n    user.is_frauder = True\n    user.frauder_reason = frauder_reasons.by_admin\n    user.last_frauder_update = timezone.now()\n    user.mobile_phone_to_reset_password_validation_code = \"1234\"\n    user.mobile_phone = \"+33611223344\"\n    user.save()\n\n    consumer = self.any_consumer()\n    self.client = HTTPSignedClient(consumer=consumer)\n\n    self.when_i_check_mobile_phone(code=\"1234\", mobile_phone=user.mobile_phone)\n    user.refresh_from_db()\n    assert_that(self.last_response.status_code, is_(403))\n    assert_that(\n        self.last_response.json(),\n        has_entry(\n            \"detail\",\n            \"\"\"Par mesure de sécurité, votre compte a été suspendu pendant 24h. \\nSi vous souhaitez le réactiver, vous pouvez nous contacter via la rubrique “A propos” > “Aide et suggestions” de l’application.\"\"\",  # noqa\",\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_rendered(self) -> None:\n    context = Context({\"user\": self.user, \"request\": self.request})\n    rendered_template = self.TEMPLATE.render(context)\n    self.assertInHTML(\"\", rendered_template)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(RENDERER_ENABLED=True)\ndef test_update_station_renderer(self) -> None:\n    \"\"\"\n    Given a promotional offer for a station,\n    When the title is updated,\n    Then the rendered station is updated\n    \"\"\"\n    offer = self.offer\n    offer.title = \"Test Promotional Offer\"\n    offer.save()\n\n    with mock.patch(\"kleen.renderers.renderers.Renderer._on_post_commit_update\") as m:  # noqa: RMS102\n        offer.update_stations()\n\n    m.assert_called_once()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_delete_scenario__incorrect_hss_pk(self) -> None:\n    \"\"\"\n    Given : A scenario\n    When : I delete this scenario, for an hss that does not exist\n    Then : I get a 404 HTTP response\n    \"\"\"\n    hss = self.client.hss\n    scenario = self.any_scenario(hss=hss)\n    last_response = self.when_i_delete_scenario(scenario_pk=scenario.pk, hss_pk=1234)\n    assert_that(last_response.status_code, is_(404), last_response.content)\n    assert_that(Scenario.objects.all(), has_length(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form(self) -> None:\n    promocode = self.any_promocode()\n\n    data = {\n        \"title\": \"Featured Promotion 1\",\n        \"description\": \"Test\",\n        \"promocode\": promocode,\n        \"image\": \"\",\n        \"slug\": \"featured-promotion-1\",\n    }\n    form = FeaturedPromotionForm(data)\n    form.is_valid()\n    fp = form.save()\n\n    assert_that(fp.deeplink, starts_with(\"com.kleen.app://featured-promotion-details/\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_scenarios(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario with new condition\n    When : I put this dict\n    Then : I get a 200 HTTP response, a dict representing the scenario with the new condition\n    \"\"\"\n    hss = self.client.hss\n    driver = hss.driver\n    scenario = self.any_scenario(hss=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_(200), last_response.content)\n    assert_that(last_response.json(), is_(not_none()))\n    assert_that(last_response.json(), has_entry(\"fields\", not_none()))\n    fields = last_response.json()[\"fields\"]\n    assert_that(fields, has_entry(\"condition\", not_none()))\n    assert_that(fields[\"condition\"], has_entry(\"data\", not_none()))\n    assert_that(fields[\"condition\"][\"data\"], has_entry(\"datetime\", new_scenario_info.condition.datetime))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_person__unauthorized(self) -> None:\n    self.client = Client()\n    hss = self.any_hss()\n    bec_contract = self.any_remote_contract(contract_number=hss.site.contract.contract_number)\n    data = self.any_create_person_data()\n    self.when_i_create_person(contract_number=bec_contract.contract_number, data=data)\n    assert_that(self.last_response.status_code, is_(status.HTTP_401_UNAUTHORIZED))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list__without_condition_action(self) -> None:\n    hss = self.any_configured_hss(account=default_climax_account)\n    driver = driver_factory.get_driver(hss=hss)\n    with requests_mock.Mocker() as m:\n        m.get(\n            \"https://padws-rec.imt.fm/WebServiceIMA/2.0/nonsecure/haListGet\",\n            json={\n                \"result\": 200,\n                \"message\": \"OK\",\n                \"has\": {\"ha\": [{\"no\": 1, \"rule\": \"\", \"exec\": \"a=1&z=4&sw=on\", \"name\": \"Sc\\xe9nario 1\"}]},\n            },\n            status_code=200,\n        )\n        scenarios = driver.scenarios.list()\n        assert_that(scenarios, is_(empty()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_perform_migration__not_needed(self) -> None:\n    hss = self.client.hss\n\n    self.when_i_migrate_hss(hss=hss, migration_type=migration_types.bec4)\n\n    assert_that(self.last_response.status_code, is_(status.HTTP_404_NOT_FOUND))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_user__has_perm__transport_warrant_attachment(self) -> None:\n    \"\"\"\n    Given\n        t1 a team\n        u1 a user in t1 with role user\n        u2 a user in t1 with role user\n        u3 a user not in t1 with role user\n        a request created by u1\n        an attachment created by u1 linked to r1\n    When I call has_perm\n    Then\n        u1 has not perm can_update and can_delete\n        u2 has not perm can_update and can_delete\n        u3 has not perm can_update and can_delete\n    \"\"\"\n    site = self.any_site()\n    u1 = self.any_user(roles=[permission_roles.user], sites=[site.pk])\n    u2 = self.any_user(roles=[permission_roles.user], sites=[site.pk])\n    u3 = self.any_user(roles=[permission_roles.user], sites=[site.pk])\n    self.any_team(site=site, with_users=[u1, u2])\n    request = self.any_quoted_request(\n        state=\"draft\",\n        creator=u1,\n        site=site,\n    )\n    attachment = request.generate_transportation_warrant_attachment()\n    assert_that(u1.has_perm(attachment_permissions.can_update, obj=attachment.file), is_(False))\n    assert_that(u2.has_perm(attachment_permissions.can_update, obj=attachment.file), is_(False))\n    assert_that(u3.has_perm(attachment_permissions.can_update, obj=attachment.file), is_(False))\n    assert_that(u1.has_perm(attachment_permissions.can_delete, obj=attachment.file), is_(False))\n    assert_that(u2.has_perm(attachment_permissions.can_delete, obj=attachment.file), is_(False))\n    assert_that(u3.has_perm(attachment_permissions.can_delete, obj=attachment.file), is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request__created_step__position__str(self) -> None:\n    request = self.any_request(state=request_states.draft)\n    Step.objects.create_at_position(\n        request=request, type=step_types.pickup, position=\"1\", perform_validation=False\n    )\n    serializer = RequestSerializer(request)\n    assert_that(serializer.data, is_(request_data(request=request)))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_force_to_error(self) -> None:\n    user = self.any_user(mangopay_card=mangopay_cards.normal)\n    order = self.any_order(payment_method=payment_methods.mangopay, refundable=True, user=user)\n\n    self.when_i_post_action(order, \"force_to_error\")\n    order.refresh_from_db()\n    assert_that(order.status, is_(order_states.failed))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__merchandise_departure(self) -> None:\n    \"\"\"\n    Given a request\n    When I use RequestFormatter with 'merchandise_departure' field to export\n    Then it returns a dict that contains the request's merchandise departure date and time\n    \"\"\"\n    request = self.any_request(state=request_states.in_progress)\n    for status in [\n        shipping_record_status.pickup_in_progress,\n        shipping_record_status.picked_up,\n        shipping_record_status.in_transit,\n    ]:\n        with self.subTest(status=status):\n            sr = request.shipping_records.first()\n            data = self.any_status_data(shipping_record=sr, status=status)\n            with handle_shipping_record_notifications():\n                sr.update_status(data)\n            sr.refresh_from_db()\n            request_csv = RequestFormatter().to_csv(request, fields=[\"merchandise_departure\"])\n            statuses = sr.status_history\n            last_status = [find_status for find_status in statuses if find_status.value == status]\n\n            time = (\n                last_status[0].notification_time.astimezone(settings.EUROPE_PARIS_ZI).strftime(\"%Y-%m-%d %H:%M:%S\")\n                if last_status\n                else \"\"\n            )\n            assert_that(request_csv[0], is_(time))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_global_promo_code_passed_expired_with_listed_value(self) -> None:\n    user = self.any_user()\n    promocode = self.any_promo_code_passed_expired(user, is_listed=True)\n\n    self.when_i_fetch_specific_promo_codes_for_user(user, promocode.code)\n    self.then_there_are_n_promocodes(0)\n    self.when_i_fetch_listed_promo_codes_for_user(user)\n    self.then_there_are_n_promocodes(0)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form__wrong_code__fourth_try(self) -> None:\n    \"\"\"\n    Given an invalid code and a user with check retry equal to 3\n    When i valid\n    Then form is invalid\n    \"\"\"\n    user = self.any_user(with_mobile_phone_verified=False)\n    user.mobile_phone_to_verify_verification_retries = 3\n    user.save()\n    form = CheckMobilePhoneForm(data={\"code\": \"wron\"}, context={\"user\": user})\n    assert_that(form.is_valid(), is_(False))\n    assert_that(user.is_frauder, is_(False))\n    assert_that(\n        form.errors,\n        is_({\"code\": [\"Le code saisi n'est pas valide.\"]}),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_hss(self) -> None:\n    self.when_i_update_hss(self.client.hss, \"updated favourites 123\")\n\n    assert_that(self.last_response.status_code, is_(204))\n    self.client.hss.refresh_from_db()\n    self.assertEqual(self.client.hss.favourite_elements, \"updated favourites 123\")\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_checkout__pending_to_ordered__mobilephoneless(self) -> None:\n    \"\"\"\n    Given a checkout in ready state for a user rci mobilephoneless\n    When i complete checkout\n    Then order has been created and is succeeded, checkout is ordered, cart is checked_out\n    \"\"\"\n    user = self.any_user(profile=user_profiles.rci, with_total_gr_card=True, with_mobile_phone_verified=False)\n    checkout = self.any_checkout(state=checkout_states.ready, payment_method=self.PAYMENT_METHOD, user=user)\n\n    order = checkout.complete()\n\n    assert_that(checkout.state, equal_to(checkout_states.ordered))\n    assert_that(checkout.cart.state, equal_to(cart_states.checked_out))\n    assert_that(order.status, equal_to(order_states.pending))\n    assert_that(checkout.order_id, not_none())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add__unauthenticated(self) -> None:\n    self.client = APIClient()\n    hss = self.any_hss()\n    self.when_i_add_code_for_hss(\n        hss_pk=hss.pk,\n        code=\"9999\",\n        label=\"RippleTests1\",\n    )\n    assert_that(self.last_response, http(status=status.HTTP_401_UNAUTHORIZED))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_register__update__password(self) -> None:\n    \"\"\"\n    Given a registered user\n    When i register with new password\n    Then user updated field has changed\n    \"\"\"\n    user = self.any_user()\n    user.mobile_phone_to_reset_password_validation_code = \"1234\"\n    user.save()\n    user.refresh_from_db()\n\n    new_password = \"New_passw0rd*\"\n    register_form = UpdatePasswordForm(\n        data={\n            \"mobile_phone\": user.mobile_phone,\n            \"new_password\": new_password,\n            \"code\": \"1234\",\n        }\n    )\n\n    assert_that(register_form.is_valid(), is_(True))\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": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_deactivate_promotional_offer__same_as_today(self) -> None:\n    \"\"\"\n    Given any promotional offer active and validity_to date same as today date\n    When I launch deactivate_promotional_offer_on_date task\n    Then promotional offer is still active\n    \"\"\"\n    date = timezone.now().date()\n\n    promotional_offer = self.any_promotional_offer(active=True)\n    promotional_offer.validity_to = date\n    promotional_offer.save()\n\n    deactivate_promotional_offer_on_date()\n\n    promotional_offer.refresh_from_db()\n    assert_that(promotional_offer.active, is_(True))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_form_off_valid_with_zone(self) -> None:\n    data = {\n        \"area\": \"1\",\n        \"zone\": \"2\",\n    }\n\n    form = CreateCameraActionForm(data=data)\n    is_valid = form.is_valid()\n\n    self.assertTrue(is_valid)\n    self.assertEqual(form.to_grammar(), \"a=1&z=2&req=img\")\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_permissions__other_request(self) -> None:\n    \"\"\"\n    Tests every framed permission on every state for every roles and every request types (my / team / other)\n    \"\"\"\n    other_request = self.any_framed_request(creator=self.u3, state=state)\n\n    request_permissions_without_cancel = [\n        perm for perm in request_permissions.all if perm != request_permissions.can_cancel\n    ]\n\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_without_cancel:\n            with self.subTest(role=role, perm=perm):\n                other_request_expected = perm in expected.get(role, {}).get(\"other_request\", {})\n                assert_that(u1.has_perm(perm, obj=other_request), is_(other_request_expected))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_save_and_quit_initial__message(self) -> None:\n    \"\"\"\n    Given any request in initial state\n    When I save and quit the form\n    Then :\n        - toast message is \"Brouillon enregistré\"\n        - toast message tag is \"info\"\n    \"\"\"\n    self.client = AuthenticatedClient()\n    request = self.any_request(state=request_states.initial, creator=self.client.user)\n    page = RequestActionPage.get(\n        client=self.client, site_slug=request.site.slug, pk=request.pk\n    ).form.save_and_quit()\n    request.refresh_from_db()\n    assert_that(request.state, is_(request_states.draft))\n    toast_messages = [m for m in messages.get_messages(page.initial_response.wsgi_request)][0]\n    assert_that(toast_messages.message, is_(\"Brouillon enregistré\"))\n    assert_that(toast_messages.tags, is_(\"default\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_wrong_request_type__fixture(self) -> None:\n    \"\"\"\n    Given quoted request\n    When I want to add day carriage\n    Then it raises AssertionError\n    \"\"\"\n    request = self.any_quoted_request(state=request_states.draft)\n    with self.assertRaises(AssertionError):\n        self.any_carriage(request=request, type=carriage_types.day)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_submit_refresh__valid(self) -> None:\n    delegation = self.any_delegation(enabled=True)\n    email = f\"test-{str(uuid4())}@test.com\"\n    password = \"Az1!erty\"\n    page = RegistrationPage.get(client=Client(), token=delegation.token).htmx_form.refresh_submit(\n        data={\"email\": email, \"password\": password}\n    )\n    assert_that(page.form.is_submit_enabled, is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_type_universe__no_matching_scenario_type_universe(self) -> None:\n    \"\"\"\n    Given : 4 scenarios type universe with target == 'pad_web'\n    When : I list scenario type unive\n    Then : Http response is 200, response contain 0 Scenario Type universe with target == 'pad_mobile'\n    \"\"\"\n    ScenarioTypeUniverse.objects.filter(target=targets.pad_mobile).delete()\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(0))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_form_off_valid(self) -> None:\n    data = {\n        \"status\": \"off\",\n    }\n\n    form = CreatePanelStatusConditionForm(data=data)\n    is_valid = form.is_valid()\n\n    self.assertTrue(is_valid)\n    self.assertEqual(form.to_grammar(), \"a1.mode==0\")  # 'off'\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_filter_pickup_time_upper(self) -> None:\n    \"\"\"\n    Given :\n        r1: a request in draft state\n        r2: a request in planned state\n        a valid form with pickup_time_range_1 (upper) set as r2 sr scheduled_pickup_time date\n    When I get_filter_queryset\n    Then the queryset only contains r2\n    \"\"\"\n    site = self.any_site()\n    r1 = self.any_framed_request(site=site, state=request_states.draft)\n    r2 = self.any_framed_request(site=site, state=request_states.planned, creator=r1.creator)\n    sr = r2.shipping_records.first()\n    form = make_request_filter_form(\n        site=r1.site,\n        user=r1.creator,\n        params={\"\": \"\"},\n    )(data={\"pickup_time_range_1\": sr.scheduled_pickup_time.strftime(\"%d/%m/%Y\")})\n    assert_that(form.is_valid())\n    qs = form.get_filter_queryset(queryset=Request.objects.all(), user=r1.creator)\n    assert_that(qs.count(), is_(1))\n    assert_that(qs.filter(pk=r2.pk).exists(), is_(True))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_accept_quote__message(self) -> None:\n    \"\"\"\n    Given any request in quote_proposal state\n    When I accept the quote on the request action page\n    Then there is no toast message\n    And\n    When I accept the quote on the request accept quote page\n    Then :\n        - toast message is \"Devis accepté\"\n        - toast message tag is \"success\"\n    \"\"\"\n    self.client = AuthenticatedClient()\n    request = self.any_request(\n        state=request_states.quote_proposal, creator=self.client.user, type=request_types.quoted\n    )\n    page_request = RequestActionPage.get(\n        client=self.client, site_slug=request.site.slug, pk=request.pk\n    ).form.accept_quote()\n    request.refresh_from_db()\n    assert_that(request.state, is_(request_states.quote_proposal))\n    assert_that(messages.get_messages(page_request.initial_response.wsgi_request), empty())\n\n    page_accept_quote = RequestAcceptQuotePage.get(\n        client=self.client,\n        url=reverse(\n            \"www:request-action-confirm_accept_quote\",\n            kwargs={\"site_slug\": request.site.slug, \"pk\": request.pk},\n        )\n        + f\"?quote={request.quotes[0].key}\",\n    ).form.submit(data={\"comment\": \"good reason\"}, next_page_class=RequestActionPage)\n    request.refresh_from_db()\n    toast_messages = [m for m in messages.get_messages(page_accept_quote.initial_response.wsgi_request)][0]\n    assert_that(toast_messages.message, is_(\"Devis accepté\"))\n    assert_that(toast_messages.tags, is_(\"success\"))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_adapter(self) -> None:\n    site = self.any_site()\n    adapter = SiteAdapter()\n    topic = adapter.topic(obj=site)\n    data = adapter.as_data(obj=site)\n    assert_that(topic, is_(\"myroad.resource.site\"))\n    assert_that(\n        data,\n        has_entries(\n            {\n                \"uri\": site.myroad_uri.value,\n                \"version\": 2,\n                \"data\": has_entries(\n                    {\n                        \"client_id\": is_(site.client_id),\n                    }\n                ),\n            }\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cancel_increment_request_version(self) -> None:\n    request = self.any_framed_request(state=request_states.draft, ready_to_submit=False)\n    request_version = request.version\n    request = request.state_machine(user=request.creator).cancel(\"test\").request\n    assert_that(request.version > request_version)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list__invalid_response_json_gsmget(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with an Essentielle panel\n        - a HssDriver\n    When:\n        - I list devices with bad data gsmGet json response\n    Then:\n        - I get a BadResponse exception\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_hm)\n    driver = driver_factory.get_driver(hss)\n    with requests_mock.Mocker(real_http=True) as m:\n        m.get(\n            re.compile(r\"/gsmGet\"),\n            status_code=200,\n            json={\"test\": \"test\"},\n        )\n        assert_that(calling(driver.devices.list), raises(BadResponse))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@with_mango_mocks()\ndef test_send_push_deeplink__unknown(self) -> None:\n    # Given :\n    #  - a user\n    #  - a message with unknown deeplinks\n    # When i send push from message\n    # Then a NotImplementedError is raised\n\n    user = self.given_user_registered_with_card(\n        card_number=MangoPayFixture.TEST_car_number_without_3DS,\n        disable_secure_mode=True,\n        consumer=self.any_consumer(source=oauth_consumer_sources.kleen),\n        with_push_token=True,\n    )\n    template = Template.objects.create(event=\"unknown\")\n    message = self.any_message(\n        user=self.client.user,\n        template=template,\n        data={},\n        with_push_deep_link=True,\n        push_deep_link=message_deep_links.my_orders,\n    )\n    with self.assertRaises(NotImplementedError):\n        message.send_push(user=user)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(CACHES=TEST_NO_CACHES, DISABLE_REDLOCK=True)\n@vcr.use_cassette()\ndef test_update__remote_control(self) -> None:\n    \"\"\"\n    Given:\n        - an Hss with Honeywell panel\n        - a HssDriver\n        - a status set to on\n    When:\n        - I update status\n    Then:\n        - I get no error\n    \"\"\"\n    for status in [HssStatus.ON, HssStatus.OFF, HssStatus.PARTIAL]:\n        with self.subTest(status=status):\n            hss = self.any_hss(remote_proxy=remote_proxies.honeywell)\n            driver = driver_factory.get_driver(hss)\n            driver.status.update(new_status=HssStatus.OFF, code=\"1001\")\n\n            updated_status = driver.status.update_remote_control(\n                new_status=status, firstname=\"test\", lastname=\"test\"\n            )\n            assert_that(updated_status, is_(status))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_canceled_states_are_migrated_in_one_label(self) -> None:\n    \"\"\"\n    Given:\n        r1: a request cancelled\n        r2: a request aborted\n        r4: a request draft\n    When I filter status canceled\n    Then r1, r2, r3 are returned\n    \"\"\"\n    site = self.any_site()\n    r1 = self.any_framed_request(site=site, state=request_states.cancelled)\n    r2 = self.any_framed_request(creator=r1.creator, site=site, state=request_states.aborted)\n    self.any_framed_request(creator=r1.creator, site=site, state=request_states.draft)\n    form = make_request_filter_form(site=site, user=r1.creator, params={\"\": \"\"})(data={\"state\": [\"cancelled\"]})\n    assert_that(form.is_valid())\n    qs = form.get_filter_queryset(queryset=Request.objects.all(), user=r1.creator)\n    assert_that(qs.count(), is_(2))\n    assert_that(qs.filter(pk=r1.pk).exists(), is_(True))\n    assert_that(qs.filter(pk=r2.pk).exists(), is_(True))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__additional_quote_label_1(self) -> None:\n    \"\"\"\n    Given a request\n    When I use RequestFormatter with 'additional_quote_label_1' field to export\n    Then it return a dict that contain request additional_quote_label_1\n    \"\"\"\n    request = self.any_request()\n    request_csv = RequestFormatter().to_csv(request, fields=[\"additional_quote_label_1\"])\n    assert_that(request_csv[0], is_(\"Emballé\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_reset_scenarios(self) -> None:\n    \"\"\"\n    Given the hss of account test.ripplemotion@gmail.com\n    When I migrate scenario, delete one of them stock the info about the migration pk & count of scenarios\n        and reset scenario migration\n    Then I have a new migration & scenario have been re-created\n    \"\"\"\n    hss = ClimaxHandlerClient().hss\n    hss.migrate_scenario_if_needed()\n    hss.scenarios.filter(state=states.ready).delete()\n    previous_scenario_count = hss.scenarios.all().count()\n    previous_migration_pk = hss.migrations.filter(type=migration_types.scenario).first().pk\n    hss.reset_scenarios()\n    hss.refresh_from_db()\n    assert_that(previous_scenario_count, is_not(hss.scenarios.all().count()))\n    assert_that(previous_migration_pk, is_not(hss.migrations.filter(type=migration_types.scenario).first().pk))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_delete_unexisting_maia_scenario(self) -> None:\n    \"\"\"\n    Given an unexisting maia scenario\n    When I delete this scenario\n    Then HTTP 404\n    \"\"\"\n    last_response = self.when_i_delete_scenario(scenario_pk=123456)\n    assert_that(last_response.status_code, is_(404))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_delete_unknown_capture(self) -> None:\n    hss = HssMixin().any_configured_hss(account=digital_alchon_account)\n    honeywell_capture = self.any_local_honeywell_capture(hss=hss)\n    capture = honeywell_capture.to_generic()\n    with self.assertRaises(ServerError):\n        hss.driver.captures.delete(capture_pk=capture.id)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_end__not_found(self) -> None:\n    \"\"\"\n    Given\n        no user subscription\n    When i end subscription type\n    Then it returns 404\n    \"\"\"\n    user = self.any_user(with_mp_user=True, mangopay_card=\"secure\")\n    self.client = AuthenticatedClient(user)\n    self.any_user_subscription(user_=user, state=UserSubscriptionState.ENDED)\n    self.when_i_end_user_subscription(slug=UserSubscriptionEndSlugReason.NOT_SATISFIED.value, details=\"\")\n    assert_that(self.last_response, http(404))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_snapshot_with_changes(self) -> None:\n    \"\"\"\n    Given a request with previous snapshot\n    When I save with change\n    Then\n        - a RequestChangedSnapshot is created\n        - a HistoricalRecord is created\n    \"\"\"\n    request = self.any_request(state=request_states.tms_transmission)\n    n_snapshot_before = RequestChangedSnapshot.objects.filter(request=request).count()\n    n_record_before = HistoricalRecord.objects.filter(request=request).count()\n\n    request.client_id = uuid4().hex\n    request.save()\n    n_snapshot_after = RequestChangedSnapshot.objects.filter(request=request).count()\n    n_record_after = HistoricalRecord.objects.filter(request=request).count()\n    assert_that(n_snapshot_after, is_(n_snapshot_before + 1))\n    assert_that(n_record_after, is_(n_record_before + 1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve_order__mangopay(self) -> None:\n    \"\"\"\n    Given an order\n    When I describe order\n    Then I get a 200 OK\n    \"\"\"\n\n    self.client = AuthenticatedClient(mangopay_card=mangopay_cards.normal)\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\n    order = 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    self.when_i_retrieve_order(order_pk=order.pk)\n\n    assert_that(self.last_response.status_code, is_(200))\n    assert \"prepaid_account_used_incl_vat\" not in self.last_response.data[\"fields\"][\"payment_details\"]\n    assert_that(\n        self.last_response.data[\"fields\"][\"payment_details\"],\n        has_entries({\"payment_card\": not_none()}),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__packing__packaging_units(self) -> None:\n    \"\"\"\n    Given a request with packaging units\n    When I use RequestFormatter with 'packing' field to export\n    Then it return a dict that contain request packing\n    \"\"\"\n    request = self.any_request(\n        transport_service=transport_services.packaging_units, with_packaging_units=True, with_carriages=False\n    )\n    request_csv = RequestFormatter().to_csv(request, fields=[\"packing\"])\n    p_packing = p_(name=\"packaging_unit.packing\")\n    packaging_unit = (\n        [v.label for v in p_packing.values if v.key == pu.packing][0] for pu in request.packaging_units.all()\n    )\n    assert_that(request_csv[0], is_(\", \".join(packaging_unit)))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_subscriber_serializer(self) -> None:\n    serializer = SubscriberSerializer(data=self.subscriber_json)\n    assert_that(serializer.is_valid(), serializer.errors)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_comment__refused_quote__only_in_history(self) -> None:\n    \"\"\"\n    Given a status refused_quote with a request having no refuse quote reason\n    When i call reason\n    Then it is none\n    \"\"\"\n    request = self.any_quoted_request(state=request_states.tms_transmission, refused_by_tms=True)\n    comment = request.comment\n    assert_that(comment, is_(none()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(ALLOW_SEND_EMAIL=True)\ndef test_send_email_twip_booking_confirmation(self) -> None:\n    \"\"\"\n    Given an order with booking\n    When i call send_email_twip_booking_confirmation\n    Then Message send method is called\n    \"\"\"\n    order = self.any_order(profile=order_profiles.dummy_booking, payment_method=payment_methods.dummy_booking)\n    with self.captureOnCommitCallbacks(execute=True):\n        order.send_email_twip_booking_confirmation()\n    self.assertEqual(len(mail.outbox), 1)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_abort__from_list(self) -> None:\n    request = self.any_framed_request(state=request_states.draft, creator=self.client.user)\n    next_url = reverse(\"www:request-action\", kwargs={\"site_slug\": request.site.slug, \"pk\": request.pk})\n    url = RequestCancelPage.get_url(site_slug=request.site.slug, pk=request.pk) + f\"?next={next_url}\"\n    page = RequestCancelPage.get(client=self.client, url=url).form.submit(\n        data={\"abort_comment\": \"toto\"}, next_page_class=RequestListPage\n    )\n    assert_that(page, instance_of(RequestListPage))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_can_cancel__team_request__with_consideration_period__from_planned(self) -> None:\n    \"\"\"\n    Given a state_machine in 'planned' state\n    When i cancel before the notice perioed\n    then permission is false\n    else permission is true\n    \"\"\"\n    for role in {\n        permission_roles.user,\n        permission_roles.supervisor,\n        permission_roles.idea_supervisor,\n        permission_roles.manager,\n        permission_roles.third_party_operator,\n        permission_roles.tms_operator,\n    }:\n        u1 = self.any_user(roles=[role], sites=[self.site.uuid])\n        self.any_team(with_users=[u1, self.u2], site=self.site)\n        first_january = datetime.datetime(2018, 1, 1, 9, 0, 0)\n        with freeze_time(first_january):\n            team_request = self.any_framed_request(creator=self.u2, state=state)\n\n        # the scheduled_time for this test is computed in\n        # iwp_myroad.test.context_managers.NotificationMock line 191\n        # wich corresponds to datetime.datetime(2018, 1, 10, 9, 0, 0)\n\n        with freeze_time(datetime.datetime(2018, 1, 3, 8, 59, 59)):  # Before notice period start\n            assert_that(\n                u1.has_perm(request_permissions.can_cancel, obj=team_request),\n                is_(can_cancel_from_planned_expected_result[role][\"team_request\"]),\n            )\n\n        with freeze_time(datetime.datetime(2018, 1, 3, 9, 0, 0)):  # After notice period start\n            expected_matcher = (\n                is_(can_cancel_from_planned_expected_result[role][\"team_request\"])\n                if role is permission_roles.tms_operator\n                else is_(False)\n            )\n            assert_that(\n                u1.has_perm(request_permissions.can_cancel, obj=team_request),\n                expected_matcher,\n            )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_featured_promotion__without_promotion(self) -> None:\n    \"\"\"\n    Create a featured promotion without promocode\n    \"\"\"\n    fp = FeaturedPromotion.objects.create(\n        title=\"Lavage gratuit\", description=\"Profitez d'un lavage gratuit\", slug=\"free_washing\"\n    )\n    assert_that(FeaturedPromotion.objects.get(uuid=fp.uuid), is_(fp))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update(self) -> None:\n    \"\"\"\n    Given a user with billing information\n    When i update billing information for this user\n    Then I update\n        - HTTP 200\n        - PMF\n        - valid data\n    \"\"\"\n    self.client = AuthenticatedClient()\n    billing_information = self.client.user.billing_information\n    self.when_i_update_billing_information(data={\"name\": \"updated name\"})\n    assert_that(self.last_response.status_code, equal_to(200))\n\n    billing_information.refresh_from_db()\n    assert_that(billing_information.name, is_(\"updated name\"))\n    assert_that(\n        self.last_response.json(),\n        has_entries(\n            {\n                \"pk\": str(billing_information.pk),\n                \"model\": \"accounts.billing_information\",\n                \"fields\": has_entries(\n                    {\n                        \"name\": \"updated name\",\n                    }\n                ),\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_product_discount__corrected_prices__discount_limit(self) -> None:\n    \"\"\"\n    Given any order with product voucher\n    Then promocode_type is product_discount\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.v2_cart_discount_percentage, version=2)\n    promocode.discount_percentage = 90\n    promocode.rules.append(promo_code_rules.valid_for_a_certain_ammount)\n    promocode.rules.append(promo_code_rules.valid_for_any_product_purchase)\n    promocode.products.add(product)\n    promocode.discount_limit = 2\n    promocode.save()\n    promocode.products.add(product)\n\n    deal = self.any_deal(\n        washing_program=self.any_washing_program(product=product),\n        price_before_discount=decimal.Decimal(5),\n        price_after_discount=decimal.Decimal(5),\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    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    orderitem = order.orderitem_set.get()\n    assert_that(orderitem.corrected_price_after_discount, is_(3))\n    assert_that(orderitem.price_after_discount, not_(orderitem.corrected_price_after_discount))\n    assert_that(orderitem.price_before_discount, is_(orderitem.corrected_price_before_discount))\n    assert_that(order.discount, is_(2))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter_additional_quote_price_2_quoted(self) -> None:\n    \"\"\"\n    Given a quoted request\n    When I use RequestFormatter with 'additional_quote_price_2' field to export\n    Then it return a dict that contain request additional_quote_price_2\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.unit_price_excl_vat = 10\n    additional_quote.label = \"Picking\"\n    additional_quote.full_clean()\n    additional_quote.save()\n    request_csv = RequestFormatter().to_csv(request, fields=[\"additional_quote_price_2\"])\n    assert_that(request_csv[0], is_(120))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_cart_item_subscription_product_voucher__after_same_deal(self) -> None:\n    \"\"\"\n    Given a user with\n        - An empty cart\n        - A subscription product voucher for product P1\n    When :\n        - I add a deal with a washing program for product P1 to the cart\n        - I add a second time a deal with a washing program for product P1 to the cart\n    Then the cart have a free deal and a normal deal\n    \"\"\"\n    product_voucher = self.any_subscription_product_voucher(\n        product=self.product, product_voucher_account=self.user.product_voucher_account_set.first()\n    )\n    cart = self.any_cart(state=cart_states.empty, user=self.user)\n\n    cart.add_item(deal=self.deal)\n    cart.add_item(deal=self.deal, subscription_voucher=product_voucher)\n\n    assert_that(cart.cartitem_set.all(), has_length(2))\n    cart_item_1, cart_item_2 = cart.cartitem_set.all()\n    assert_that(\n        [cart_item_1.deal.price_after_discount, cart_item_2.deal.price_after_discount],\n        contains_inanyorder(decimal.Decimal(\"0\"), decimal.Decimal(\"10\")),\n    )\n    assert_that(\n        [cart_item_1.deal.availability, cart_item_2.deal.availability],\n        contains_inanyorder(deal_availability.in_stock, deal_availability.out_of_stock),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_export__global_check(self) -> None:\n    \"\"\"\n    Given a user who already created an export setting with 'creation_time', 'qualification_time',\n    'collection_date', 'state' as field to export\n    When I get the request export form\n    Then there is only 'request_type' field to be checked\n    \"\"\"\n    self.any_request_export_setting(\n        creator=self.client.user,\n        site=self.client.current_site,\n        fields_to_export=[\"creation_time\", \"qualification_time\", \"collection_date\", \"state\"],\n    )\n    page = RequestListPage.get(client=self.client, site_slug=self.client.current_site.slug)\n    page = page.notifications_offcanvas.new_export()\n    assert isinstance(page, RequestListPage)\n    assert page.request_export_form\n    checked_fields = [\n        field_name for field_name, field_value in page.request_export_form.export_group.items() if field_value\n    ]\n    assert_that(checked_fields, has_length(1))\n    assert_that(checked_fields, has_item(\"switch_state\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_delete_scenario(self) -> None:\n    \"\"\"\n    Given : A scenario\n    When : I delete this scenario\n    Then : I get a 200 HTTP response, the scenario is deleted\n    \"\"\"\n    hss = self.client.hss\n    scenario = self.any_master_scenario(hss=hss)\n    last_response = self.when_i_delete_scenario(scenario_pk=scenario.pk)\n    assert_that(last_response.status_code, is_(204), last_response.content)\n    assert_that(calling(scenario.panel_scenario.refresh_from_db), raises(Scenario.DoesNotExist))\n    assert_that(calling(scenario.maia_scenario.refresh_from_db), raises(MaiaScenario.DoesNotExist))\n    assert_that(calling(scenario.refresh_from_db), raises(MasterScenario.DoesNotExist))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__thermometer_low_battery(self) -> None:\n    \"\"\"\n    Given:\n        - A thermometer in low battery faulty state\n    When:\n        - I serialize it\n    Then:\n        - I get a thermometer with low_battery faulty state\n    \"\"\"\n    thermometer_json = load(\"climax_thermometer_low_battery.json\")\n    hss = self.any_hss()\n    serializer = ListResponseSerializer(data=thermometer_json)\n    serializer.is_valid(raise_exception=True)\n    devices = serializer.save(hss=hss)\n\n    thermometer = devices.thermometers[0]\n    assert_that(thermometer.faulty_states, contains_inanyorder(faulty_states.low_battery))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve_resynchro_task(self) -> None:\n    hss = self.any_hss()\n    task = self.any_resynchro_task(hss=hss, source=resynchro_task_sources.private_api)\n    url = reverse(\"private:v34:scenarios:resynchrotask-detail\", args=(task.id,))\n    response = self.client.get(url)\n    assert_that(response.status_code, is_(200), response.content)\n    assert_that(\n        response.json(),\n        has_entries(\n            {\n                \"pk\": task.id,\n                \"model\": \"scenarios.resynchro-task\",\n                \"fields\": has_entries(\n                    {\n                        \"state\": resynchro_task_states.pending,\n                        \"source\": resynchro_task_sources.private_api,\n                        \"creation_time\": task.creation_time.astimezone().isoformat(),\n                        \"error_message\": \"\",\n                    }\n                ),\n            }\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_quoted_threshold_error(self) -> None:\n    \"\"\"\n    Given any quoted request with min threshold > max\n    When i full clean\n    Then i obtain a validation error\n    \"\"\"\n    request = self.any_request(type=request_types.quoted)\n    request.min_threshold = 5.0\n    request.max_threshold = 2.0\n    with self.assertRaises(ValidationError):\n        request.full_clean()\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_recover_master_scenario(self) -> None:\n    \"\"\"\n    Given a master scenario\n    When I recover the scenario\n    Then I get a 20O HTTP response\n    \"\"\"\n    panel_scenario = self.any_scenario(hss=self.client.hss, state=states.publishing)\n    maia_scenario = self.any_maia_scenario(with_device=True)\n    master_scenario = self.any_master_scenario(\n        hss=self.client.hss, panel_scenario=panel_scenario, maia_scenario=maia_scenario\n    )\n    self.when_i_recover_scenario(hss_pk=self.client.hss.pk, scenario_pk=master_scenario.pk)\n    assert_that(self.last_response.status_code, is_(200))\n    assert_that(self.last_response.json(), is_(scenario_pmf_data()))\n    assert_that(self.last_response.json()[\"fields\"][\"state\"], is_(states.published))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(NEED_DEFAULT_PROMOCODE=True)\ndef test_delete__not_authenticated(self) -> None:\n    self.client = AnonymousClient()\n    self.when_i_delete_card()\n\n    assert_that(self.last_response, http(403))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_issue_is_fixed__user(self) -> None:\n    site = self.any_site()\n    u1 = self.any_user(roles=[permission_roles.tms_operator], sites=[site.pk])\n    u2 = self.any_user(roles=[permission_roles.idea_supervisor], sites=[site.pk])\n    self.client = AuthenticatedClient(user=u1)\n\n    request = self.any_quoted_request(\n        state=request_states.qualification,\n        creator=u2,\n        site=site,\n        with_additional_quotes=True,\n        with_attachments=[request_attachments.carriage_adr],\n    )\n    page = RequestActionPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk)\n    file_browse_button = page.soup.find(\"button\", attrs={\"name\": \"additionalquote_set-0-attachment-file-browse\"})\n    file_input = page.soup.find(\"input\", attrs={\"name\": \"additionalquote_set-0-attachment-file-input\"})\n    assert_that(file_browse_button.has_attr(\"readonly\"), is_(True))\n    assert_that(file_input.has_attr(\"disabled\"), is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_str(self) -> None:\n    \"\"\"\n    Given any subscription product\n    When I display object\n    Then str is correct\n    \"\"\"\n    subscription_type = self.any_subscription_type()\n    s_product = subscription_type.subscriptionproduct_set.first()\n    assert_that(str(s_product), is_(f\"{s_product.quantity} {s_product.product} ({s_product.uuid})\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_str(self) -> None:\n    camera = self.any_local_honeywell_camera()\n    assert_that(str(camera), is_(f\"Camera {camera.id} [name: {camera.name}]\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_operator(self) -> None:\n    seller = self.any_seller()\n    seller.full_clean()\n    seller.save()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order__with_promocode_offered_credit_pack_no_station(self) -> None:\n    \"\"\"\n    Given a offered credit pack order from app\n    When order objects is generated\n    Then order item is not linked to a station\n    \"\"\"\n    user = self.any_user(with_credits=True, credits=10000)\n    order = self.any_order(user=user, profile=order_profiles.credits_pack, with_promocode=True)\n    assert_that(order.orderitem_first.station_pk, is_(none()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__not_found(self) -> None:\n    with self.assertRaises(NotFoundException):\n        RequestFilterStatesPage.get(client=self.client, site_slug=\"unknown\")\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form_valid_power_switch_action_with_duration(self) -> None:\n    data = {\n        \"area\": \"1\",\n        \"zone\": \"2\",\n        \"status\": \"on\",\n        \"duration\": \"20\",  # 20 seconds\n    }\n\n    form = BlindOrSwitchActionForm(data=data)\n    is_valid = form.is_valid()\n    power_switch = form.to_model(instance_pk=1, is_blind=False)\n\n    self.assertTrue(is_valid)\n    self.assertEqual(type(power_switch).__name__, \"PowerSwitchAction\")\n    self.assertEqual(power_switch.area, 1)\n    self.assertEqual(power_switch.zone, 2)\n    self.assertEqual(power_switch.status, \"onduring\")\n    self.assertEqual(power_switch.duration, 20)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list__json_decode_error(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with ClimaxKiz panel\n        - a HssDriver\n    When:\n        - I list blinds with a JSONDecodeError (bad body value from cassette)\n        !! Don't erase this cassette\n    Then:\n        - I get a BadResponse exception\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    driver = driver_factory.get_driver(hss)\n    with mock.patch(\"requests.Response.json\", side_effect=JSONDecodeError(\"test\", \"test\", 0)):  # noqa: RMS102\n        with self.assertRaises(BadResponse):\n            driver.blinds.list()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_create_scenarios(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario\n    When : I post this dict\n    Then : I get a 201 HTTP response, a dict with one scenario\n    \"\"\"\n    hss = self.client.hss\n    scenario = self.any_scenario(hss=hss, save=False)\n    data = self.any_scenario_data(scenario)\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(Scenario.objects.all(), has_length(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cleanup_admin_log(self) -> None:\n    \"\"\"\n    Given an old and recent log\n    When I cleanup\n    Then old log delete\n    \"\"\"\n    user_ct = ContentType.objects.get_for_model(self.user)\n    old_log = LogEntry.objects.log_action(\n        user_id=self.user.pk,\n        content_type_id=user_ct.pk,\n        object_id=str(self.user.pk),\n        object_repr=str(self.user),\n        action_flag=ADDITION,\n        change_message=\"Test old log\",\n    )\n    one_year_ago = now() - timedelta(days=366)\n    old_log = LogEntry.objects.latest(\"id\")  # get the created log\n    old_log.action_time = one_year_ago\n    old_log.save()\n    new_log = LogEntry.objects.log_action(\n        user_id=self.user.pk,\n        content_type_id=user_ct.pk,\n        object_id=str(self.user.pk),\n        object_repr=str(self.user),\n        action_flag=ADDITION,\n        change_message=\"Test old log\",\n    )\n    cleanup_admin_log()\n    new_log.refresh_from_db()\n    assert_that(calling(old_log.refresh_from_db), raises(LogEntry.DoesNotExist))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_submit_error__steps_errors_not_visible(self) -> None:\n    \"\"\"\n    Given a request ready to submit\n    When I post with an error in request action forms\n    Then form is in error but request update steps errors is not visible\n    \"\"\"\n    request = self.any_framed_request(state=request_states.draft, creator=self.client.user)\n    with self.assertRaises(RequestActionPage.RequestForm.Error) as em:\n        RequestActionPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk).form.submit(\n            data={\"references-identifier\": \"\"}\n        )\n    request_update_step_errors_div = em.exception.soup.find(\n        \"div\", attrs={\"id\": \"request_update_step_forms_errors\"}\n    )\n    assert_that(request_update_step_errors_div, none())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_codes_assigned(self) -> None:\n    \"\"\"\n    Given  essentielle code\n    Given a bec person person with this code_pk\n    When i list codes\n    then I get an reponse with status 200 and the code assign\n    \"\"\"\n    hss = self.any_hss(contract=self.client.hss.site.contract)\n    contract_number = hss.site.contract.contract_number\n    code = self.any_essentielle_code(hss=self.client.hss, code=\"4321\", index=1)\n    contract = self.any_remote_contract(contract_number=contract_number)\n    assert contract.persons\n    person = contract.persons[0]\n    data = self.any_update_person_data(index=person.index, code_pk=f\"1_{code.index}\")\n    self.when_i_update_person(contract_number=contract_number, person_uuid=person.uuid, data=data)\n    self.when_i_list_codes(hss=self.client.hss)\n    assert_that(self.last_response.status_code, is_(status.HTTP_200_OK))\n    assert_that(self.last_response.json()[0], has_entry(\"fields\", has_entry(\"person_pk\", is_(person.uuid))))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_power_condition_keeped(self) -> None:\n    self.any_scenario_type_with_status_condition_type(StatusConditionType.POWER_GREATER_THAN)\n    condition = PowerCondition(pk=1, area=1, zone=1, power=1000)\n    scenario = Scenario(pk=1, condition=condition, action=None)\n\n    scenario_types = ScenarioType.objects.scenario_types_for_scenario(self.hss.remote_proxy, scenario)\n\n    self.assertEqual(scenario_types.count(), 1)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_add__code_conflict_error(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with an Essentielle panel\n        - a HssDriver\n        - an existing code\n        - data to add a new code with the same code value\n    When:\n        - I add a new code\n    Then:\n        - a CodeConflict exception is raised\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_hm)\n    driver = driver_factory.get_driver(hss)\n    code = get_random_string(length=4, allowed_chars=(\"1234567890\"))\n    data = {\n        \"master_code\": \"1234\",\n        \"code\": code,\n        \"name\": get_random_string(length=7),\n    }\n    driver.codes.add(data=data)\n    assert_that(calling(driver.codes.add).with_args(data=data), raises(CodeConflict))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_state__quoted(self) -> None:\n    request_type = request_types.quoted\n    with self.subTest(request_type=request_type):\n        request = self.any_request(state=request_states.tms_shipment_refused, type=request_type)\n        header = request_header_actions(request=request, user=request.creator)\n\n        expected: Dict[str, Any] = expected_actions[request_type]\n\n        left_actions = [action.action for action in header[\"left_actions\"]]\n        right_actions = [action.action for action in header[\"right_actions\"]]\n        assert_that(left_actions, only_contains(*expected[\"principal\"][\"left\"]))\n        assert_that(right_actions, only_contains(*expected[\"principal\"][\"right\"]))\n        assert_that(header[\"secondary_actions\"], has_length(len(expected[\"secondary\"])))\n        for i, actions in enumerate(header[\"secondary_actions\"]):\n            secondary_actions = [action.action for action in actions]\n            expected_secondary = expected[\"secondary\"]\n            assert_that(secondary_actions, only_contains(*expected_secondary[i]))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_error(self) -> None:\n    serializer = WidgetCancelURLSerializer(data={})\n    call = calling(serializer.is_valid).with_args(raise_exception=True)\n    assert_that(call, raises(serializers.ValidationError))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_rating__wrong_user(self) -> None:\n    \"\"\"\n    Given\n        a delivery from another user\n    When I rate\n    Then 200 OK\n    \"\"\"\n    self.client = AuthenticatedClient()\n    delivery = self.any_delivery(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(404))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_consumer_make_token_same_random_password(self) -> None:\n    consumer = self.any_consumer()\n    user = self.any_user()\n    with mock.patch.object(  # noqa: RMS102\n        Consumer, \"make_random_password\", side_effect=[\"123\", \"123\", \"123\", \"123\", \"321\"]\n    ):\n        token: Token = consumer.make_token(user=user, device_id=None)\n        token = consumer.make_token(user=user, device_id=None)\n        assert_that(token.key, is_(\"321\"))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_settings_email_send_not_allowed(self) -> None:\n    \"\"\"\n    Given a settings that doesn't allow sending email\n    When evaluating the specification\n    It returns False\n    \"\"\"\n    spec = OrderPurchaseEmailCanBeSentSpecification()\n    assert_that(spec.is_satisfied_by(self.order), is_(False))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__reference_to_be_used(self) -> None:\n    request = self.any_request(state=request_states.initial)\n    assert request.reference_to_be_used\n    serializer = RequestSerializer(request)\n    assert_that(\n        serializer.data[\"references\"],\n        has_item(has_entries({\"type\": reference_types.to_be_used, \"value\": not_none()})),\n    )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_scenarios__incorrect_scenario_type_pk(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario with a scenario_type_pk wich not exist\n    When : I put this dict\n    Then : I get a 404 HTTP response\n    \"\"\"\n    hss = self.client.hss\n    scenario = self.any_scenario(hss=hss)\n    data = self.any_scenario_data(scenario, scenario_type_pk=1234)\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_get_all_customer_service_subjects(self) -> None:\n\n    self.client = AuthenticatedClient()\n    self.any_customer_service_subject()\n    self.any_customer_service_subject()\n\n    self.when_i_list_customer_service_subjects()\n\n    assert_that(self.last_response.status_code, is_(200))\n    assert_that(self.last_response.data[0], is_pmf(model_name=\"faq.customer_service_subject\"))\n    assert_that(\n        self.last_response.data[0][\"fields\"],\n        has_entries(\n            {\n                \"slug\": not_(empty()),\n                \"title\": not_(empty()),\n                \"article_title\": not_(empty()),\n                \"article_slug\": not_(empty()),\n                \"parent_slug\": empty(),\n            }\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_loader__error(self) -> None:\n    loader = ShippingRecordACSTransCalledEventLoader()\n    sr = self.any_shipping_record()\n    data = self.any_shipping_record_acs_trans_called_data(shipping_record=sr, error=\"API Error\")\n    event = loader.on_message(\"\", data)\n    assert event\n    assert_that(event.shipping_record.uri.value, starts_with(\"myroad://shipping_record/\"))\n    assert_that(event.timestamp, is_(instance_of(datetime.datetime)))\n    assert_that(event.data, instance_of(str))\n    assert_that(event.error, is_(\"API Error\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_supervisor__my_team(self) -> None:\n    \"\"\"\n    Given\n        t1 a team\n        u1 a user in t1\n        u2 a user in t1 with role supervisor\n        u3 a user not in t1 with role supervisor\n        a request created by u1\n    When I call has_perm\n    Then\n        u2 has perm can_view\n        u2 has not perm can_update and can_delete\n        u3 has not perm\n    \"\"\"\n    site = self.any_site()\n    u1 = self.any_user(sites=[site.pk])\n    u2 = self.any_user(roles=[permission_roles.supervisor], sites=[site.pk])\n    u3 = self.any_user(roles=[permission_roles.supervisor], sites=[site.pk])\n    self.any_team(site=site, with_users=[u1, u2])\n    request = self.any_request(site=site, type=request_types.quoted, creator=u1)\n    attachment = self.any_attachment(user=u1, site=site, request=request)\n    assert_that(u2.has_perm(attachment_permissions.can_view, obj=attachment), is_(True))\n    assert_that(u2.has_perm(attachment_permissions.can_update, obj=attachment), is_(False))\n    assert_that(u2.has_perm(attachment_permissions.can_delete, obj=attachment), is_(False))\n    assert_that(u3.has_perm(attachment_permissions.can_view, obj=attachment), is_(False))\n    assert_that(u3.has_perm(attachment_permissions.can_update, obj=attachment), is_(False))\n    assert_that(u3.has_perm(attachment_permissions.can_delete, obj=attachment), is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_user__contact_info(self) -> None:\n    \"\"\"\n    Given :\n        - a random user\n    When :\n        - I get contact infos\n    Then :\n        - contact infos are loaded\n    \"\"\"\n    user = self.any_user()\n    contacts = user.contact_info.split(\" \")\n    assert user.contact_info is not None\n    assert f\"({user.email})\" == contacts[-1]\n", "output": "3"}
{"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_parse_condition_alarm_status__invalid(self) -> None:\n    parsed_condition = Kiz3PadMobileParser().parse_condition(1, \"a1.alarm\")\n    assert_that(parsed_condition, is_(None))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_factory_create_scenarios_service(self) -> None:\n    \"\"\"\n    Given a driver of type essentielle, a scenario for this driver\n    When I ask the factory to create a service scenario for my panel\n    Then I get an instance of EssentielleScenario\n    \"\"\"\n    hss = HssMixin().any_configured_hss(account=default_essentielle_account)\n    scenario = self.any_scenario(hss=hss)\n    service_scenarios = factory_create_scenarios_service(\n        hss.driver.scenarios,\n        [\n            scenario.pk,\n        ],\n        \"Dummy Scenario\",\n        scenario.info.condition,\n        scenario.info.actions[0],\n    )\n    assert_that(service_scenarios[0], instance_of(EssentielleScenario), type(service_scenarios[0]))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_check_credits_value(self) -> None:\n    prepaid_account = self.any_prepaid_account_personal()\n    prepaid_account.credits = 1650\n    prepaid_account.save()\n\n    assert_that(prepaid_account.price_incl_vat, is_(decimal.Decimal(\"16.50\")))\n    assert_that(prepaid_account.price_excl_vat, is_(decimal.Decimal(\"13.75\")))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_rendered(self) -> None:\n    context = Context({\"user\": self.user, \"request\": self.request})\n    rendered_template = self.TEMPLATE.render(context)\n    self.assertInHTML(\"here\", rendered_template)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__status_off(self) -> None:\n    \"\"\"\n    Given\n        - a powerswitch with status set to off\n    When\n        - I serialize it\n    then\n        - I get a valid json with energy set to None\n    \"\"\"\n    powerswitch = self.any_powerswitch(status=powerswitch_status.off)\n    serializer = PowerSwitchSerializer(powerswitch)\n    data = serializer.data\n    assert_that(\n        data, has_entries({\"pk\": powerswitch.device_id, \"model\": \"hss.power_switch\", \"fields\": anything()})\n    )\n    assert_that(\n        data[\"fields\"],\n        has_entries(\n            {\n                \"area\": 1,\n                \"energy\": none(),\n                \"id2\": powerswitch.device_id,\n                \"name\": powerswitch.name,\n                \"status\": powerswitch.status,\n                \"type\": \"power_switch\",\n                \"icon\": powerswitch.icon,\n                \"faulty_states\": not_none(),\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add__from_cross_selling(self) -> None:\n    \"\"\"\n    Given\n        - a deal\n        - a cart\n    When i add wiht from_cross_selling is True\n    Then\n        - 201 CREATED\n        - cart item from_cross_selling is True\n    \"\"\"\n    deal = self.any_deal()\n\n    self.client = AuthenticatedClient()\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,\n        item_type=create_cart_item_types.deal,\n        reference=deal.id,\n        quantity=1,\n        from_cross_selling=True,\n    )\n\n    assert_that(self.last_response, http(201))\n    assert_that(cart.cartitem_set.get().from_cross_selling, is_(True))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_admin_list(self) -> None:\n    response = self.client.get(reverse(\"admin:www_globalframednotificationssettings_changelist\"))\n    assert_that(response.status_code, is_(200))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cancel_button__request_export_form(self) -> None:\n    \"\"\"\n    Given an user and a request in state in_progress\n    When i click on button cancel\n    Then request is cancelled\n    \"\"\"\n    request_export = self.any_request_export(creator=self.client.user, state=request_export_states.in_progress)\n    page = RequestListPage.get(client=self.client, site_slug=self.client.sites[0].slug)\n    page = page.request_exports_list(state=request_export_states.in_progress)[0].cancel_form.cancel(\n        next_page_class=RequestListPage\n    )\n    request_export.refresh_from_db()\n    assert request_export.state == request_export_states.canceled\n    assert_that(page.request_exports_list(state=request_export_states.in_progress), empty())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_shipping_records_attachments_empty(self) -> None:\n    \"\"\"\n    Given a request with a shipping records with no attachment\n    When I call shipping_records_attachments\n    Then I get an empty list\n    \"\"\"\n    request = self.any_request(type=request_types.framed, state=request_states.tms_transmission)\n    self.any_shipping_record(request=request)\n    assert_that(len(request.shipping_records_attachments), is_(0))\n    assert_that(request.shipping_records_attachments, empty())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__unauthenticated(self) -> None:\n    self.client = Client()\n    site = self.any_site()\n    with self.assertRaises(RedirectException):\n        UserNotificationsPage.get(client=self.client, site_slug=site.slug)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve(self) -> None:\n    \"\"\"\n    Given an order\n    When I retrieve it\n    Then 200 OK\n    \"\"\"\n    self.client = AuthenticatedClient(mangopay_card=mangopay_cards.normal)\n    order = self.any_order(user=self.client.user, payment_method=payment_methods.mangopay, api_version=API_VERSION)\n    self.when_i_retrieve_order_securemoderedirecurl(transaction_id=order.transaction.mangopay_id)\n\n    assert_that(self.last_response, http(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_scenario_info_field__no_condition(self) -> None:\n    \"\"\"\n    Given a scenario with scenario without condition\n    When i save scenario\n    Then scenario has a scenario info in valid format\n    \"\"\"\n    scenario_info = self.any_scenario_info(driver=self.client.hss.driver)\n    scenario_info.condition = None\n    action_type = scenario_info.actions[0].__class__\n    hss = self.client.hss\n    scenario = self.any_scenario(hss=hss, scenario_info=scenario_info, save=False)\n    scenario.save()\n    assert_that(scenario, not_none())\n    assert_that(scenario.info, not_none())\n    assert_that(scenario.info.condition, none())\n    assert_that(scenario.info.actions, is_not(empty()))\n    action = scenario.info.actions[0]\n    assert_that(action, instance_of(action_type))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_non_kleen_station_with_duplicate_source_id(self) -> None:\n    zone_context = ZoneContextMixin().any_zone_context()\n    brand = Brand.objects.create(name=\"test brand\", zone_context=zone_context)\n    with self.assertRaises(IntegrityError):\n        Station.objects.create(\n            brand=brand,\n            name=\"station test\",\n            source=\"twip\",\n            source_id=\"123\",\n            zone_context=zone_context,\n            info_state=info_states.complete,\n            address_1=\"a\",\n            postal_code=\"1\",\n            city=\"a\",\n            country=\"a\",\n            image=\"a\",\n            enabled=True,\n            exceptional_closure=False,\n            is_partner=False,\n        )\n        Station.objects.create(\n            brand=brand,\n            name=\"station test\",\n            source=\"twip\",\n            source_id=\"123\",\n            zone_context=zone_context,\n            info_state=info_states.complete,\n            address_1=\"a\",\n            postal_code=\"1\",\n            city=\"a\",\n            country=\"a\",\n            image=\"a\",\n            enabled=True,\n            exceptional_closure=False,\n            is_partner=False,\n        )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_customer_informations(self) -> None:\n    response = self.maxxing_client.send_transaction(\n        club_card=self.club_card,\n        price=\"25.00\",\n        ean=\"3425909001014\",\n        family_code=\"5021\",\n        payment_method=\"15\",\n        payment_method_detail=\"CB\",\n    )\n    assert_that(response.status_code, is_(200))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_with_booking__good(self) -> None:\n    booking = self.any_booking()\n    data = {\"reference\": booking.pk, \"quantity\": 1, \"item_type\": create_cart_item_types.booking}\n    form = CartItemCreateForm(data=data, cart=self.cart)\n    assert_that(form.is_valid(), is_(True))\n    form.add(user=self.any_user(secure_mode_version=secure_mode_versions.secure_mode_3ds2))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_account_adapter(self) -> None:\n    account = self.any_prepaid_account()\n    account.users.add(account.owner)\n    adapter = AccountAdapter()\n    key = adapter.key(account)\n    topic = adapter.topic(account)\n    payload = adapter.as_data(account)\n    data = payload[\"data\"]\n    assert_that(key, is_(str(account.id)))\n    assert_that(topic, is_(\"resource.kleen.account\"))\n    assert_that(payload[\"uri\"], account.uri)\n\n    assert_that(\n        data,\n        has_entries(\n            {\n                \"name\": account.name,\n                \"account_type\": account.account_type,\n                \"amount\": account.credits,\n                \"users\": has_item(account.owner.uri),\n                \"owner\": account.owner.uri,\n            }\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_read_contract__unauthenticate(self) -> None:\n    self.client = Client()\n    self.when_i_get_contract(contract_number=default_climax_account.contract_numbers[0])\n    assert_that(self.last_response.status_code, is_(status.HTTP_401_UNAUTHORIZED))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__qualification_time__framed(self) -> None:\n    \"\"\"\n    Given a framed request\n    When I use RequestFormatter with 'qualification_time' field to export\n    Then it return a dict that contain request tms_transmission_time\n    \"\"\"\n    request = self.any_framed_request(request_states.planned)\n    request_csv = RequestFormatter().to_csv(request, fields=[\"qualification_time\"])\n    assert request.tms_transmission_time\n    assert_that(\n        request_csv[0],\n        is_(request.tms_transmission_time.astimezone(settings.EUROPE_PARIS_ZI).strftime(\"%Y-%m-%d %H:%M:%S\")),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_person__not_found(self) -> None:\n    person = self.any_remote_person(default_climax_account.contract_numbers[0])\n    data = self.any_update_person_data(first_name=\"Test API\")\n    with mock.patch.object(BecDriverV4, \"update_person\", side_effect=NotFound):  # noqa: RMS102\n        self.when_i_update_person(person_uuid=person.uuid, data=data)\n        assert_that(self.last_response.status_code, is_(status.HTTP_404_NOT_FOUND))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promotional_offer_two_required_free__update(self) -> None:\n    \"\"\"\n     Given a station with promotional offer for a free item with two required items\n        of which for one the required quantity is 2\n    When\n        I add the required items to cart\n        I add one more of the required items\n        I remove that item\n    The promotional offer is still applied\n    \"\"\"\n    cart = self.any_cart()\n    promotional_offer = self.promotional_offer_multiple_free\n    station = self.station\n\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    required = promotional_offer.required_products.filter(product=required_deal_1.washing_program.product).first()\n    required.quantity = 2\n    required.save()\n\n    self.add_item(cart, required_deal_1, quantity=2)\n    self.add_item(cart, required_deal_2)\n    cart_item_2 = self.add_item(cart, required_deal_2)\n    self.remove_item(cart, cart_item_2)\n\n    assert_that(cart.cartitem_set.count(), is_(3))\n    cart_item_1 = cart.cartitem_set.filter(deal=required_deal_1).first()\n    assert_that(cart_item_1, is_not(None))\n    cart_item_2 = cart.cartitem_set.filter(deal=required_deal_2).first()\n    assert_that(cart_item_2, is_not(None))\n    cart_item_3 = cart.cartitem_set.filter(deal=discounted_deal).first()\n    assert_that(cart_item_3, is_not(None))\n    assert_that(\n        cart.meta,\n        has_entries(\n            {\n                \"promotional_offers\": has_entries(\n                    {\n                        \"used_cart_items\": contains_inanyorder(\n                            has_entries(\n                                {\"id\": str(cart_item_1.id), \"quantity\": 2, \"offer_id\": str(promotional_offer.uuid)}\n                            ),\n                            has_entries(\n                                {\"id\": str(cart_item_2.id), \"quantity\": 1, \"offer_id\": str(promotional_offer.uuid)}\n                            ),\n                        ),\n                        \"offered_cart_items\": contains(\n                            has_entries({\"id\": str(cart_item_3.id), \"offer_id\": str(promotional_offer.uuid)})\n                        ),\n                    }\n                ),\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_is_exceptionally_closed__exceptional_closure(self) -> None:\n    \"\"\"\n    Given a station with exceptional_closure True\n    Then is_exceptionally_closed is True\n    \"\"\"\n    station = self.any_station(exceptional_closure=True)\n    assert_that(station.is_exceptionally_closed, is_(True))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_read_contract__http_error(self) -> None:\n    \"\"\"\n    Given an IMTDriver & & a valid user & a valid contract\n    When I read contract With an http error response\n    Then I get an IMTDriver excption\n    \"\"\"\n    with mock.patch.object(Response, \"raise_for_status\", side_effect=HTTPError):  # noqa: RMS102\n        assert_that(\n            calling(self.driver.read_contract).with_args(contract=self.contract), raises(IMTDriverException)\n        )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_permissions__other_request(self) -> None:\n    \"\"\"\n    Tests every quoted permission on every state for every roles and every request types (my / team / other)\n    \"\"\"\n    other_request = self.any_quoted_request(creator=self.u3, 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                other_request_expected = perm in expected.get(role, {}).get(\"other_request\", {})\n                assert_that(u1.has_perm(perm, obj=other_request), is_(other_request_expected))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter_additional_quote_quantity_1_framed(self) -> None:\n    \"\"\"\n    Given a framed request\n    When I use RequestFormatter with 'additional_quote_quantity_1' field to export\n    Then it return a dict that contain request additional_quote_quantity_1\n    \"\"\"\n    request = self.any_framed_request()\n    request_csv = RequestFormatter().to_csv(request, fields=[\"additional_quote_quantity_1\"])\n    assert_that(request_csv[0], is_(empty()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_deactivate_from_twip_web(self) -> None:\n    with transaction.atomic():\n        fixtures = load_fixture_pack(\"default\")\n    user = fixtures[\"resource.tw.user\"][0]\n    consumer = self.any_consumer(profile=consumer_profiles.twip_web)\n    user.consumer_set.set([consumer])\n    self.client = AuthenticatedClient(user=user, consumer=consumer)\n    reason = \"My specific reason\"\n    self.when_i_deactivate_account(reason=reason)\n    self.client.user.refresh_from_db()\n\n    assert_that(self.client.user.is_active, is_(False))\n    assert_that(self.client.user.mobile_phone, is_(\"\"))\n    assert_that(self.client.user.mobile_phone_to_verify, is_(\"\"))\n    assert_that(self.client.user.mobile_phone_is_verified, is_(False))\n    assert_that(self.client.user.allow_newsletter, is_(False))\n    assert_that(self.client.user.allow_crm, is_(False))\n    assert_that(self.client.user.gdpr_comment, is_(f\"demande de suppression de compte via w@w - {reason}\"))\n    assert_that(self.client.user.anonymized_reason, is_(AnonymizedReason.BY_CUSTOMER.value))\n    assert_that(Token.objects.filter(user=self.client.user).all(), empty())\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_schedulers__validation_error_when_overriding_start_date(self) -> None:\n    \"\"\"\n    Given : A credits pack with a scheduler on a specific period\n    When : I create a second scheduler with a start date that overrides with an existing period\n    Then : Validation error is raised\n    \"\"\"\n    credits_pack = self.any_credits_pack()\n    start_date = timezone.now()\n    end_date = start_date + timedelta(days=7)\n    first_scheduler = self.any_credits_pack_scheduler(\n        credits_pack=credits_pack, start_date=start_date, end_date=end_date\n    )\n    second_start_date = first_scheduler.start_date + timedelta(days=2)\n    second_end_date = first_scheduler.end_date + timedelta(days=2)\n    with self.assertRaises(ValidationError) as e:\n        self.any_credits_pack_scheduler(\n            credits_pack=credits_pack, start_date=second_start_date, end_date=second_end_date\n        )\n    assert_that(e.exception.messages[0], is_(\"A scheduler is already configured on this period or a part of it.\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_is_not_frauder_by_phone_but_by_admin(self) -> None:\n    \"\"\"\n    given :\n        - a valid user\n        - which is a frauder by admin\n        - which is logged in\n        - a request\n    when :\n        - i check user permission IsNotFrauderByAdmin\n    then :\n        - `has_permission`is true\n        - user's property `is_frauder`is true\n    \"\"\"\n    user = self.any_user()\n    request = RequestFactory().get(\"/fake\")\n    request.user = user\n    user.is_frauder = True\n    user.frauder_reason = frauder_reasons.by_admin\n    user.last_frauder_update = timezone.now()\n    user.save()\n    has_permission = IsNotFrauderByPhoneValidation().has_permission(request, None)\n    assert_that(has_permission, is_(True))\n    assert_that(user.is_frauder, is_(True))\n    assert_that(user.frauder_reason, is_not(frauder_reasons.phone_validation_fail))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_booking_product_name(self) -> None:\n    \"\"\"\n    Given any credits pack scheduler in progress\n    When I buy credit pack\n    Then order has promocode_type = increased_bonus\n    \"\"\"\n    booking = self.any_twip_api_booking(with_purchases=True)\n    orderitem = booking.get_related_order.orderitem_first\n    assert_that(orderitem.product_name, is_(booking.purchase_set.first().raw[\"offer_name\"]))\n    assert_that(orderitem.product_name, is_(orderitem.deal.washing_program.name))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_multi_cart_item_product_voucher__affected_by_promotional_offer(self) -> None:\n    \"\"\"\n    Given\n        - a user with 2 product vouchers for product P1\n        - A promotional offer given an offered product for a P1 purchase\n        - A cart with a P1 offered from product voucher, a product offered from promotional offer\n    When I add 2 P1 on this cart\n    Then the cart have:\n        - 2 free deal\n        - 1 deal not free\n        - 3 products offer\n    \"\"\"\n    product_voucher_account = self.user.product_voucher_account_set.first()\n    self.any_product_voucher(product=self.product, product_voucher_account=product_voucher_account)\n    self.any_product_voucher(product=self.product, product_voucher_account=product_voucher_account)\n    cart = self.any_cart(state=cart_states.empty, user=self.user)\n    offered_product = self.any_product(sku=\"offered_product\")\n    offered_wp = self.any_washing_program(product=offered_product, station=self.wp.station)\n    self.any_deal(washing_program=offered_wp)\n    self.any_promotional_offer(\n        station=self.wp.station, discounted_washing_program=offered_wp, required_washing_program=self.wp\n    )\n    cart.add_item(deal=self.deal)\n\n    cart.add_item(deal=self.deal, quantity=2)\n\n    P1_set = cart.cartitem_set.filter(deal__washing_program=self.wp)\n    assert_that(P1_set, has_length(3))\n    assert_that(P1_set.filter(deal__price_after_discount_basic=0), has_length(2))\n    assert_that(cart.cartitem_set.get(deal__washing_program=offered_wp).quantity, equal_to(3))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_migrate_scenario(self) -> None:\n    \"\"\"\n    Given an hss\n    When i migrate scenario\n    Then i have scenarios and an hss migration type \"scenario\"\n    \"\"\"\n    hss = self.client.hss\n    self.any_migration(hss=hss, type=migration_types.scenario, completed=False)\n\n    self.when_i_migrate_hss(hss, migration_types.scenario)\n    assert_that(self.last_response.status_code, is_(status.HTTP_200_OK), self.last_response)\n    assert_that(hss.migrations.filter(completed=True).all(), has_length(1))\n    scenarios = Scenario.objects.filter(hss=hss)\n    assert_that(scenarios, is_not(empty()))\n    assert_that(scenarios, has_length(greater_than_or_equal_to(4)))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__unauthenticated(self) -> None:\n    self.client = Client()\n    request = self.any_framed_request(state=request_states.draft)\n    with self.assertRaises(RedirectException):\n        RequestActionPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_perm(self) -> None:\n    site = self.any_site()\n    for role in permission_roles.all:\n        user = self.any_user(roles=[role], sites=[site.uuid])\n        with self.subTest(role=role):\n            expected_result = role in {\n                permission_roles.user,\n                permission_roles.tms_operator,\n                permission_roles.idea_supervisor,\n                permission_roles.supervisor,\n                permission_roles.manager,\n            }\n            has_perm = user.has_perm(site_permissions.can_create_quoted_request, obj=site)\n            assert_that(has_perm, is_(expected_result))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_run_probe_close_alert(self) -> None:\n    \"\"\"\n    Given the time betwen the start and stop range\n    Given more than probe alert_threshold fast_status\n    Given a token value at 2\n    Given the probe in alert status and monitoring mode\n    When I run probe\n    Then a monitoring Event are create\n    \"\"\"\n    Event.objects.all().delete()\n    AMQPEvent.objects.all().delete()\n\n    assert Probe.objects.count() == 1\n    probe: Probe = Probe.objects.first()\n    freeze_date = datetime.datetime(\n        year=2022,\n        month=10,\n        day=27,\n        hour=probe.daily_range_start,\n        minute=30,\n        second=31,\n        tzinfo=timezone.get_current_timezone(),\n    )\n    probe.mode = mode.monitoring\n    probe.last_run = freeze_date - datetime.timedelta(minutes=1)\n    probe.save()\n    with mock.patch.object(timezone, \"now\", return_value=freeze_date):  # noqa: RMS102\n        probe.status = status.alert\n        probe.save()\n        nb_of_fast_status = probe.alert_threshold + 1\n        for i in range(nb_of_fast_status):\n            self.any_event(type=events.fast_status)\n\n        cache.set(\"probe_token\", 2)\n\n        run_probe()\n\n        probe.refresh_from_db()\n        event = Event.objects.first()\n        assert_that(event.source, is_(mode.monitoring))\n        assert_that(event.status, is_(status.ok))\n        assert_that(event.value, is_(nb_of_fast_status))\n\n        assert_that(probe.status, is_(status.ok))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_no_raw(self) -> None:\n    qr_code = self.any_qr_code(save=True)\n    qr_code.raw = None\n    with self.assertRaises(ValidationError) as e:\n        qr_code.clean()\n    assert_that(e.exception.messages[0], is_('\"If info_state is complete, raw value cannot be None'))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_accessible_contracts(self) -> None:\n    \"\"\"\n    Given a user with his own contract and a delegation\n    When i get all accessible contracts\n    Then I get 2 contracts\n    \"\"\"\n    user = self.any_user()\n\n    self.any_contract(user=user)\n    honeywell_contract = self.any_honeywell_contract()\n\n    self.any_delegation(contract=honeywell_contract, user=user, enabled=True)\n\n    contracts = user.contracts_accessible_by_user\n    assert_that(len(contracts), is_(equal_to(2)))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_duplicate_request__without_attachment(self) -> None:\n    \"\"\"\n    Given:\n        - any user\n        - any request with requester, packaging_units and steps\n    When I duplicate it without attachment\n    Then I get another request copying over the first one\n    \"\"\"\n    user = self.any_user()\n    request = self.any_request()\n    request.requester = self.any_user()\n    duplicated_request = Request.objects.duplicate(request=request, creator=user)\n\n    packaging_units_matcher = [\n        packaging_unit_entity(pu, with_attachment=False) for pu in request.packaging_units.all()\n    ]\n    steps_matcher = [step_entity(step) for step in request.steps.all()]\n    steps_pu_matcher = [\n        step_pu_entity(step_pu) for step in request.steps.all() for step_pu in step.step_packaging_units.all()\n    ]\n\n    assert_that(duplicated_request.state, is_(request_states.initial))\n    assert_that(duplicated_request, request_entity(request=request, creator=user))\n    assert_that(duplicated_request.packaging_units.all(), contains_inanyorder(*packaging_units_matcher))\n    assert_that(duplicated_request.steps.all(), contains_inanyorder(*steps_matcher))\n    assert_that(\n        StepPackagingUnit.objects.filter(step__request=duplicated_request), contains_inanyorder(*steps_pu_matcher)\n    )\n\n    assert_that(duplicated_request.attachments.all(), is_(empty()))\n    [assert_that(pu.adr_attachment, is_(none())) for pu in duplicated_request.packaging_units.all()]\n    [assert_that(pu.packing_attachment, is_(none())) for pu in duplicated_request.packaging_units.all()]\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promo_code_promotion__valid_once(self) -> None:\n    backend = ValidOncePromotion()\n    cart = self.any_cart(\n        state=cart_states.active,\n        profile=cart_profiles.deal_washing,\n        deal=self.washing_deal_tmf,\n    )\n    promo_code = self.promo_code_1\n    assert_that(backend.validate(promo_code, cart), is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_from_generic(self) -> None:\n    thermometer = self.any_local_climax_thermometer()\n    assert_that(Thermometer.objects.from_generic(thermometer.to_generic()), is_(thermometer))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_checkout__pending__to_ready(self) -> None:\n    \"\"\"\n    Given a mangopay checkout in pending state\n    When i refresh checkout\n    Then checkout is ready and valid\n    \"\"\"\n    checkout = self.any_checkout(\n        state=checkout_states.pending,\n        payment_method=self.PAYMENT_METHOD,\n        with_ip_address=True,\n        with_browser_info=True,\n    )\n\n    checkout.refresh(consumer=checkout.cart.user.consumer_set.first())\n\n    assert_that(checkout.state, equal_to(checkout_states.ready))\n    assert_that(checkout.order_id, none())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_category(self) -> None:\n    \"\"\"\n    Given any category\n    When I get category\n    then I get\n        an HTTP 200\n        containing one category\n    \"\"\"\n    category = self.any_category()\n    self.client = AuthenticatedClient()\n    self.when_i_get_category(slug=category.slug)\n\n    assert_that(self.last_response.status_code, is_(200))\n    assert_that(self.last_response.data, is_pmf(model_name=\"faq.category\"))\n    assert_that(self.last_response.data[\"pk\"], is_(category.uuid))\n    assert_that(\n        self.last_response.data[\"fields\"],\n        has_entries(\n            {\n                \"slug\": not_(empty()),\n                \"title\": not_(empty()),\n                \"slug_icon\": not_(empty()),\n                \"order\": not_(empty),\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promo_code_v2_offered_voucher__no_product_to_offer(self) -> None:\n    \"\"\"\n    Given a v2 promocode type offered_voucher\n    When I try to set product_to_offer to None\n    Then it raise an ValidationError exception\n    \"\"\"\n    promo_code = self.any_promocode(version=2, profile=promocode_profiles.v2_offered_voucher)\n    promo_code.product_to_offer = None\n    with self.assertRaises(ValidationError) as e:\n        promo_code.clean()\n    assert_that(e.exception.error_dict, has_entry(\"product_to_offer\", not_(empty())))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_user_adapter__with_club_card(self) -> None:\n    user = self.any_user()\n    self.any_club_card(user=user)\n    user.refresh_from_db()\n    adapter = UserAdapter()\n    key = adapter.key(user)\n    topic = adapter.topic(user)\n    payload = adapter.as_data(user)\n    data = payload[\"data\"]\n    assert_that(key, is_(str(user.user_id)))\n    assert_that(topic, is_(\"resource.kleen.user\"))\n    assert_that(payload[\"uri\"], user.uri)\n    assert_that(data[\"is_club_owner\"], is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_register__update__empty_phone__seed_user(self) -> None:\n    \"\"\"\n    Given a seed user\n    When i update register with empty phone\n    Then user mobile phone is empty and not verified\n    \"\"\"\n    user = self.any_user(profile=user_profiles.seed)\n    data = self.any_update_register_data(user=user, mobile_phone=\"\")\n\n    register_form = UpdateRegisterForm(data=data, instance=user)\n    assert_that(register_form.is_valid(), is_(True))\n    register_form.register(user_pk=user.pk, request=None)\n\n    user.refresh_from_db()\n    assert_that(user.mobile_phone_to_verify, is_(\"\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_article__anonymous_user(self) -> None:\n    \"\"\"\n    Given any article and an anonymous user\n    When I get article\n    then I get\n        an HTTP 200\n        containing one article\n    \"\"\"\n    article = self.any_article()\n\n    self.client = AnonymousClient()\n    self.when_i_get_article(slug=article.slug)\n\n    assert_that(self.last_response.status_code, is_(200))\n    assert_that(self.last_response.data[\"pk\"], is_(article.uuid))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_offered_product_promotional_offer__corrected_prices(self) -> None:\n    user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n    product = self.any_product()\n    wp = self.any_washing_program(product=product)\n    deal = self.any_deal(\n        washing_program=wp,\n        price_after_discount=decimal.Decimal(\"10\"),\n        price_before_discount=decimal.Decimal(\"10\"),\n    )\n\n    offered_product = self.any_product()\n    offered_wp = self.any_washing_program(product=offered_product, station=wp.station)\n    self.any_deal(\n        washing_program=offered_wp,\n        price_after_discount=decimal.Decimal(\"10\"),\n        price_before_discount=decimal.Decimal(\"10\"),\n    )\n\n    self.any_promotional_offer(\n        required_washing_program=wp, discounted_washing_program=offered_wp, station=wp.station\n    )\n\n    cart = self.any_cart(user=user, state=cart_states.empty)\n    cart.add_item(deal=deal)\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.discount, is_(decimal.Decimal(\"10.000000\")))\n\n    orderitem_offered = order.orderitem_set.exclude(deal_pk=deal.pk).first()\n    assert_that(orderitem_offered.corrected_price_before_discount, is_(decimal.Decimal(\"10.000000\")))\n    assert_that(orderitem_offered.corrected_price_after_discount, is_(0))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promotional_offer_discounted_multiple_inverse(self) -> None:\n    \"\"\"\n    Given a station with promotional offer for a discounted item\n    When\n        I add two discounted item to cart\n        I add two required item to cart\n    Then the discounted items are discounted automatically\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, discounted_deal.washing_program.best_deal, quantity=2)\n    self.add_item(cart, required_deal, quantity=2)\n    assert_that(cart.cartitem_set.count(), is_(2))\n    for cart_item in cart.cartitem_set.all():\n        assert_that(cart_item.quantity, is_(2))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_create_scenario_on_and_partial(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario with on_and_partial condition\n    When : I post this dict\n    Then : I get a 201 HTTP response, a dict with one scenario\n    \"\"\"\n    hss = self.client.hss\n    scenario = self.any_scenario(hss=hss, save=False)\n    data = self.any_scenario_data(scenario)\n    data[\"scenario_type\"] = 79\n    data[\"condition\"][\"fields\"][\"status\"] = \"on_and_partial\"  # import constante\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(Scenario.objects.all(), has_length(1))\n    assert_that(MasterScenario.objects.count(), is_(1))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update__polling_can_commit__response_value_error(self) -> None:\n    \"\"\"\n    Given\n        - a Hss with a honeywell panel\n        - a HssDriver\n        - a honeywell powerswitch\n    When\n        - I update powerswitch name with an invalid json in the body response while polling\n         after the update name request\n    Then\n        - I get an updated powerswitch\n    \"\"\"\n    hss = self.any_configured_hss(account=default_honeywell_account)\n    driver = driver_factory.get_driver(hss)\n    honeywell_powerswitch = self.any_honeywell_powerswitch(hss=hss)\n    new_name = get_random_string(8)\n    assert_that(\n        calling(driver.power_switches.update_name).with_args(\n            device_id=str(honeywell_powerswitch.id), new_name=new_name\n        ),\n        raises(BadResponse),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_scenarios__incorrect_scenario_type_pk(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario with a scenario_type_pk wich not exist\n    When : I put this dict\n    Then : I get a 404 HTTP response\n    \"\"\"\n    hss = self.client.hss\n    scenario = self.any_scenario(hss=hss)\n    data = self.any_scenario_data(scenario, scenario_type_pk=1234)\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_from_generic(self) -> None:\n    capture = self.any_local_honeywell_capture()\n    assert_that(Capture.objects.from_generic(capture.to_generic()), is_(capture))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_new_user_notifiers_debug__no_notifier(self) -> None:\n    user = self.any_user()\n    assert_that(user.get_new_user_notifiers_debug, is_(\"Règle J+N :  Aucun notifier\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_leave__error(self) -> None:\n    state_scenarios = [\n        {\"actual\": request_states.initial, \"expected\": request_states.initial},\n        # {\"actual\": request_states.draft, \"expected\": request_states.draft},\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            with self.assertRaises(RequestActionPage.RequestForm.Error):\n                with mock.patch(  # noqa: RMS102\n                    \"iwp_myroad.www.views.RequestActionFormView.are_forms_valid\", side_effect=lambda x: False\n                ) as m:\n                    RequestActionPage.get(\n                        client=self.client, site_slug=request.site.slug, pk=request.pk\n                    ).form.leave()\n            request.refresh_from_db()\n            m.assert_called_once()\n            assert_that(request.state, is_(scenario[\"expected\"]))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_person_serializers(self) -> None:\n    \"\"\"\n    Given a hss\n    Given a code associated to the hss\n    Given data with code_index\n    When I serialize data\n    Then data is valid\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    code = self.any_climax_kiz_code(hss=hss)\n    data = {\"code_pk\": f\"1_{code.index}\"}\n    serializer = UpdatePersonSerializer(context={\"contract\": hss.site.contract}, data=data)\n    serializer.is_valid(raise_exception=True)\n    assert_that(serializer.validated_data, has_entry(\"code_pk\", code.index))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_authenticated(self) -> None:\n    data: Dict[str, Any] = {\"email\": \"test.ripplemotion@gmail.com\", \"password\": \"Pa$$w0rd\", \"device_id\": \"123\"}\n    backend = PadMobileFRAuthBackend()\n    user = backend.authenticate(**data)\n    assert_that(user, not_none())\n    assert_that(user, is_(backend.get_user(user.id)))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_mail_header__tags(self) -> None:\n    \"\"\"\n    Ensure request_mail_header template tags works\n    \"\"\"\n    context = Context({\"myroad_prefix\": \"test\", \"request\": self.request})\n    self.header_template.render(context)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_first_last_order_date(self) -> None:\n    \"\"\"\n    Given a user with 2 order\n    When I get first and last order date\n    Then it matches with the orders date\n    \"\"\"\n    user = self.any_user()\n    order_1 = self.any_order(user=user)\n    order_2 = self.any_order(user=user)\n    assert_that(user.first_order_date, is_(order_1.sold_date))\n    assert_that(user.last_order_date, is_(order_2.sold_date))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_alert_comment_refused(self) -> None:\n    \"\"\"\n    Given any framed request in cancelled state with an abort comment\n    When I call alert_comment passing the request comment\n    Then it return a dict containing :\n        alert_type = \"alert-danger\"\n        icon = \"ti ti-square-x\"\n    \"\"\"\n    abort_comment = \"Commentaire d'annulation\"\n    request = self.any_request(type=request_types.framed, state=request_states.cancelled)\n    request.abort_comment = abort_comment\n    request.save()\n\n    comment = request.comment\n\n    result = alert_comment(comment=comment)\n\n    assert_that(\n        result,\n        has_entries(\n            {\n                \"comment\": comment,\n                \"alert_type\": \"alert-danger\",\n                \"icon\": \"ti ti-square-x\",\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_make_device_action_maia_exception(self) -> None:\n    \"\"\"\n    Given a device not in maia\n    When I make device action\n    Then 502\n    \"\"\"\n    device = self.any_local_device()\n    assert device.status == DeviceStatus.ok.value\n    capability = device.capabilities[0]\n    action = DeviceCapabilities(capability).autorized_actions[0]\n    self.when_i_make_device_action(\n        hss=device.connection.hss, device_pk=device.pk, data={\"action\": action, \"capability\": capability}\n    )\n    assert_that(self.last_response.status_code, is_(status.HTTP_502_BAD_GATEWAY))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_read_hss__with_bad_contract(self) -> None:\n    \"\"\"\n    Given : A logged in User with email, an HSS with bad contract\n    When : I read infos of this HSS\n    Then : status code of the response is 200\n    Then : hss support codes is False\n    Then : hss support partial mode is False\n    \"\"\"\n    hss = self.client.hss\n    hss.site.contract.capabilities = []\n    hss.site.contract.save()\n    self.when_i_read_hss(hss)\n    assert_that(self.last_response.status_code, is_(200))\n    hss.refresh_from_db()\n    assert_that(hss.support_codes, is_(False))\n    assert_that(hss.support_partial_mode, is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_not_publish_framed(self) -> None:\n    for state in {request_states.initial, request_states.dropped}:\n        with self.subTest(state=state):\n            with mock.patch(\"iwp.replication.sites.client.publish\") as m:  # noqa: RMS102\n                self.any_framed_request(state=state, creator=self.user)\n            m.assert_not_called()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_read_user_by_country_code_and_subscriber_id(self) -> None:\n    driver = IMTDriver()\n    account = default_climax_account\n    user = driver.read_user(country_code=account.country_code, subscriber_id=account.subscriber_id)\n    assert_that(user, is_(not_none()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_click_request(self) -> None:\n    user = self.any_user(roles=[permission_roles.manager, permission_roles.user])\n    request = self.any_request(creator=user, state=request_states.completed)\n    self.client = AuthenticatedClient(user=user)\n    page = (\n        RequestListPage.get(client=self.client, site_slug=request.site.slug)\n        .requests_list[0]\n        .detail.click(next_page_class=RequestActionPage)\n    )\n    assert_that(page, is_(RequestActionPage))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_register__update__password__empty_old_new(self) -> None:\n    \"\"\"\n    Given a registered user\n    When i register with an empty new password and old password\n    Then user updated field has changed\n    \"\"\"\n    user = self.any_user()\n    first_name = \"titi\"\n    data = self.any_update_register_data(user=user, password=\"\", new_password=\"\", first_name=first_name)\n    register_form = UpdateRegisterForm(data=data, instance=user)\n\n    assert_that(register_form.is_valid(), is_(True))\n    register_form.register(user_pk=user.pk, request=None)\n\n    user.refresh_from_db()\n    assert_that(user.first_name, is_(first_name))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list__invalid_response_json(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with Essentielle panel\n        - a HssDriver\n    When:\n        - I list captures an invalid json response (bad values into body from cassette)\n    Then:\n        - I get a BadResponse exception\n    \"\"\"\n    hss = self.any_configured_hss(account=papillon_essentielle_account)\n    driver = driver_factory.get_driver(hss)\n    with mock.patch.object(ListResponseSerializer, \"is_valid\", side_effect=ValidationError):  # noqa: RMS102\n        assert_that(calling(driver.captures.list), raises(BadResponse))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_permissions__team_request(self) -> None:\n    \"\"\"\n    Tests every framed permission on every state for every roles and every request types (my / team / other)\n    \"\"\"\n    team_request = self.any_framed_request(creator=self.u2, state=state)\n\n    request_permissions_without_cancel = [\n        perm for perm in request_permissions.all if perm != request_permissions.can_cancel\n    ]\n\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_without_cancel:\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_update_not_implemented(self) -> None:\n    hss = self.any_hss()\n    driver = KeypadDriver(hss)\n    with self.assertRaises(NotImplementedError):\n        driver.update_name(device_id=\"\", new_name=\"\")\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_parse_action(self) -> None:\n    parser = Kiz3Parser()\n    parser.condition_semantic_impl = ImaConditionsSemanticsPadMobileImpl\n    hss = self.any_configured_hss(account=default_climax_account)\n    scenario_type = self.any_scenario_type()\n    scenario_info = self.any_scenario_info(driver=hss.driver)\n    scenario = self.any_scenario(hss=hss, scenario_info=scenario_info, scenario_type=scenario_type, save=False)\n    assert_that(calling(parser.parse_action).with_args(scenario.pk, \"text\", []), raises(NotImplementedError))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_notify_users_shipping_record_document_added__consignment_received(self) -> None:\n    \"\"\"\n    Given\n        - any request with should_send_added_document_notification = True\n        - a user rule on_add transport_document\n        - a consignement received for request's shipping record\n    When I call notify_users_shipping_record_document_added\n    Then should_send_added_document_notification is False\n    \"\"\"\n    site = self.any_site()\n    user = self.any_user(sites=[site.pk])\n    self.any_user_rule(\n        user=user, request_type=request_types.framed, event=events.on_add, state=request_states.transport_document\n    )\n    request = self.any_request(\n        type=request_types.framed, state=request_states.tms_transmission, creator=user, site=site\n    )\n    self.any_shipping_record(request=request, extra_status=[shipping_record_status.consignment_received])\n    request.should_send_added_document_notification = True\n    request.save()\n    tasks.notify_users_shipping_record_document_added(request_pk=request.pk)\n    request.refresh_from_db()\n    assert_that(request.should_send_added_document_notification, is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_power_switch_status__when_bad_power_switch_id(self) -> None:\n    \"\"\"\n    Given a regular user account with Honeywell HSS,\n    when I update power switch status,\n    then the response is 404.\n    \"\"\"\n    self.when_i_update_power_switch_status(self.client.hss, 12345)\n\n    assert_that(self.last_response.status_code, is_(404))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with ClimaxKiz panel\n        - a HssDriver\n    When:\n        - I list blinds\n    Then:\n        - I get a list of Blinds\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    driver = driver_factory.get_driver(hss)\n    blinds = driver.blinds.list()\n    assert_that(blinds, not_(empty()))\n    assert_that(blinds[0].uuid, is_(not_none()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_unpublish_scenario__scenario_mode_different_hss_delegation(self) -> None:\n    \"\"\"\n    Given : A scenario with is_on = False, group = away while hss scenario_mode = daily, state is published\n    When : I unpublish this scenario\n    Then : I get a 400 HTTP response, with a dict\n           The scenario hasn't been updated\n           HSS is returned\n\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    scenario = self.any_scenario(hss=hss, state=states.published)\n    scenario.group = groups.away\n    scenario.is_on = False\n    scenario.save(\n        update_fields=[\n            \"is_on\",\n            \"group\",\n        ]\n    )\n    last_response = self.when_i_unpublish_scenario(scenario.pk)\n    scenario.refresh_from_db()\n    assert_that(last_response.status_code, is_(400))\n    assert_that(last_response.json(), has_entry(\"group\", not_none()))\n    assert_that(scenario.is_on, is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cart_update__unexisting_prepaid_account(self) -> None:\n    \"\"\"\n    Given a user with a cart and a prepaid account\n    When I serialize an unexisting prepaid_account_pk\n    Then I get an exception indicating that this prepaid account does not exist\n    \"\"\"\n    user = self.any_user()\n    cart = self.any_cart(user=user)\n    data = {\"prepaid_account_pk\": uuid.uuid4()}\n    form = CartUpdateForm(data, cart=cart, consumer=user.consumer_set.first())\n    assert_that(form.is_valid(), is_(False))\n    assert_that(form.errors, has_entry(\"prepaid_account_pk\", is_(not_none())))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_scenario_devices__http_error(self) -> None:\n    hss = self.any_configured_hss(account=default_climax_account)\n    driver = driver_factory.get_driver(hss=hss)\n    with requests_mock.Mocker() as m:\n        m.get(\"https://padws-rec.imt.fm/WebServiceIMA/2.0/nonsecure/deviceListGet\", json={}, status_code=405)\n        assert_that(calling(driver.scenarios.list_scenario_devices), raises(HTTPError))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_consumer__equipment_add_code(self) -> None:\n    broker_url = settings.IMA_BROKER_URL_EQUIPMENT\n    equipment_queue = queues.equipment_add_code\n\n    self.generate_change(broker_url=broker_url, queue=equipment_queue, body={\"Prom\": \"123456\"})\n\n    event = self.consume_event(broker_url=broker_url, event=events.equipment_add_code, queue=equipment_queue)\n\n    assert_that(event, has_property(\"state\", event_states.pending))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_not_implemented(self) -> None:\n    hss = self.any_hss()\n    driver = CaptureDriver(hss)\n    with self.assertRaises(NotImplementedError):\n        driver.get(filename=\"\")\n", "output": "2"}
{"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_add_cart_item_subscription_product_voucher__quantity_2(self) -> None:\n    \"\"\"\n    Given a user with\n        - An empty cart\n        - A product voucher for product P1\n    When I add two deal with a washing program for product P1 to the cart\n    Then the cart have a free deal and a normal deal\n    \"\"\"\n    product_voucher = self.any_subscription_product_voucher(\n        product=self.product, product_voucher_account=self.user.product_voucher_account_set.first()\n    )\n    cart = self.any_cart(state=cart_states.empty, user=self.user)\n\n    cart.add_item(deal=self.any_deal(washing_program=self.wp), subscription_voucher=product_voucher, quantity=2)\n\n    assert_that(cart.cartitem_set.all(), has_length(2))\n    cart_item_1, cart_item_2 = cart.cartitem_set.all()\n    assert_that(\n        [cart_item_1.deal.price_after_discount, cart_item_2.deal.price_after_discount],\n        contains_inanyorder(decimal.Decimal(\"0\"), decimal.Decimal(\"10\")),\n    )\n    assert_that(\n        [cart_item_1.deal.availability, cart_item_2.deal.availability],\n        contains_inanyorder(deal_availability.in_stock, deal_availability.out_of_stock),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promo_code__valid_for_a_limited_time__too_late(self) -> None:\n    backend = ValidForALimitedTimeCart()\n    cart = self.any_cart(\n        state=cart_states.active,\n        profile=cart_profiles.deal_washing,\n        deal=self.washing_deal_tmf,\n    )\n    with freeze_time(timezone.now() + datetime.timedelta(days=2)):\n        assert_that(\n            backend.validate(self.promo_code_1, cart),\n            is_((False, PromoCodeValidationErrorMessages.CODE_EXPIRED.value)),\n        )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_has_perm(self) -> None:\n    \"\"\"\n    Given\n        s1 site\n        c1 a shipping charter\n        u1 a user 3rd party operator in s1 and c1\n        r1 a request in s1\n        a1 an attachment which is not linked to an additional quote\n    When i call has perm\n    Then\n        u1 has perm can_view a1\n        u1 has not perm can_update a1\n        u1 has not perm can_delete a1\n    \"\"\"\n\n    site = self.any_site()\n    u1 = self.any_user(roles=[permission_roles.third_party_operator], sites=[site.pk])\n    c1 = self.any_charter(with_users=[u1])\n    request = self.any_quoted_request(site=site, by_partner=c1, state=request_states._3rd_party_transmission)\n    attachment = self.any_attachment(user=u1, site=site, request=request)\n    assert_that(u1.has_perm(attachment_permissions.can_view, obj=attachment), is_(True))\n    assert_that(u1.has_perm(attachment_permissions.can_update, obj=attachment), is_(True))\n    assert_that(u1.has_perm(attachment_permissions.can_delete, obj=attachment), is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_permissions__other_request(self) -> None:\n    \"\"\"\n    Tests every quoted permission on every state for every roles and every request types (my / team / other)\n    \"\"\"\n    other_request = self.any_quoted_request(creator=self.u3, state=state, by_partner=self.c1)\n    for role in permission_roles.all:\n        u1 = self.any_user(roles=[role], sites=[self.site.uuid])\n        self.c1.users.set([u1])\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                other_request_expected = perm in expected.get(role, {}).get(\"other_request\", {})\n                assert_that(u1.has_perm(perm, obj=other_request), is_(other_request_expected))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_read_bad_station(self) -> None:\n    self.client = AuthenticatedClient(self.voucher.product_voucher_account.owner)\n    self.when_i_get_station_voucher_prices(station_pk=123, url_params={\"product_voucher_id\": self.voucher.pk})\n    assert_that(self.last_response, http(404))\n    assert_that(\n        self.last_response.json(),\n        is_(\n            {\"details\": \"no station\"},\n        ),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form_errors__tms_transmission__packing_missing(self) -> None:\n    request = self.any_request(\n        type=request_types.quoted, state=request_states.tms_transmission, ready_to_submit=True\n    )\n    pu = request.packaging_units.get()\n    pu.packing = \"\"\n    pu.save()\n    data, _ = self.any_packaging_unit_form_data(\n        packaging_units=request.packaging_units.all(), prefix=\"packaging_units\"\n    )\n    formset = make_pu_formset_class(instance=request, user=request.creator)(instance=request, data=data)\n\n    assert_that(formset.is_valid(), is_(False))\n    assert_that(formset.errors, contains_exactly(has_entry(\"packing\", not_(empty()))))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__unauthenticated(self) -> None:\n    self.client = Client()\n    request = self.any_request()\n    with self.assertRaises(RedirectException):\n        RequestNotificationsPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__unauthenticated(self) -> None:\n    self.client = Client()\n    request = self.any_framed_request(state=request_states.draft)\n    with self.assertRaises(RedirectException):\n        RequestCancelPage.get(client=self.client, site_slug=request.site.slug, pk=request.pk)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_name(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with ClimaxKiz panel\n        - a HssDriver\n        - a climax blind\n    When:\n        - I update blind's name\n    Then:\n        - I get an updated blind\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    driver = driver_factory.get_driver(hss)\n    climax_blind = self.any_climax_blind(hss=hss)\n    new_name = get_random_string(15)\n    updated_climax_blind = driver.blinds.update_name(device_id=climax_blind.zigbee_id, new_name=str(new_name))\n    assert_that(updated_climax_blind, not_none())\n    assert_that(updated_climax_blind.name, is_(str(new_name)))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_expired__no_registration_time(self) -> None:\n    \"\"\"\n    Given a user with a mp card not used created less than 30 mn ago without registration time\n    When I call manager method\n    Then user's card is returned\n    \"\"\"\n    user = self.any_user(mangopay_card=mangopay_cards.normal)\n    mangopay_card = user.mangopay_users.first().card\n    mangopay_card._mangopay_card_registration_datetime = None\n    mangopay_card.save()\n\n    expired_cards = MangopayCard.objects.expired_cards()\n\n    assert_that(expired_cards, is_not(empty()))\n    assert_that(len(expired_cards), equal_to(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette(match_on=[\"vcr_take_capture_with_hss_matcher\"])\ndef test_take_capture_sync(self) -> None:\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    climax_camera = self.any_climax_camera(hss=hss)\n    camera = climax_camera.to_generic()\n    filename = self.when_i_take_capture_sync(driver=hss.driver, camera=camera)\n    image = hss.driver.captures.get(filename=filename)\n    assert_that(image, is_(not_none()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list__frauder_by_phone_validation(self) -> None:\n    \"\"\"\n    Given :\n        - an order\n        - a user frauder by phone validation\n    When I list\n    Then I get 403\n    \"\"\"\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\n    self.any_order(user=self.client.user, api_version=self.API_VERSION)\n\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(\n            \"detail\",\n            \"\"\"Par mesure de sécurité, votre compte a été suspendu pendant 24h. \\nSi vous souhaitez le réactiver, vous pouvez nous contacter via la rubrique “A propos” > “Aide et suggestions” de l’application.\"\"\",  # noqa\",\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_save_and_quit_increment_request_version(self) -> None:\n    request = self.any_quoted_request(state=request_states.qualification)\n    request_version = request.version\n    request = request.state_machine(user=request.creator).save_and_quit().request\n    assert_that(request.version > request_version)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_unique_name__creation_visible_in_app(self) -> None:\n    \"\"\"\n    Given\n        - a credit pack visible in app\n    When I create credit pack with same name and visible in app\n    Then I get a Validation Error\n    \"\"\"\n    c1 = self.any_credits_pack(visible_in_app=True)\n\n    with self.assertRaises(ValidationError):\n        self.any_credits_pack(visible_in_app=True, name=c1.name)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_global_dashboard__model(self) -> None:\n    self.any_global_dashboard()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_wp_offered_promo_code__with_credit_pack(self) -> None:\n    \"\"\"\n    Given a cart with credit pack\n          a promocode offering a wp\n    When I try to validate the promocode for the cart\n    Then it's not valid\n    \"\"\"\n    cart = self.any_cart(profile=cart_profiles.deal_credits_pack, state=cart_states.active)\n    promo_code = self.any_promocode(\n        version=2,\n        profile=promocode_profiles.v2_offered_wp,\n    )\n    promocode_not_valid = promo_code.clean_promocode_validation_for_cart(cart)\n    assert_that(promocode_not_valid, is_(not_(none())))\n    assert_that(promocode_not_valid[1], is_(PromoCodeValidationErrorMessages.CODE_INELIGIBLE.value))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_type_universe__no_scenario_type_univers(self) -> None:\n    \"\"\"\n    Given : 0 inital scenarios type universe\n    When : I list scenario type universe\n    Then : Http response is 200, response contain 0 Scenario Type\n    \"\"\"\n    ScenarioTypeUniverse.objects.all().delete()\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(0))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order__to__success(self) -> None:\n    \"\"\"\n    Given an order pending\n    When i refresh\n    Then order is in success status\n    \"\"\"\n    user = self.any_user(with_total_gr_card=True)\n    order = self.any_order(user=user, status=order_states.pending, payment_method=self.PAYMENT_METHOD)\n\n    while order.status not in order_states.purchase_final:\n        order.refresh()\n\n    transactions = Transaction.objects.filter(options__order_id=order.id)\n    assert_that(order.status, equal_to(order_states.success))\n    assert_that(transactions[0].order_detail_reference, is_(order_detail_references.wash))\n    assert_that(order.promocode_transaction, none())\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_superuser(self) -> None:\n    user = User.objects.create_superuser(email=\"test@ripplemotion.fr\", password=\"1234\")\n    assert_that(user.email, is_(\"test@ripplemotion.fr\"))\n    assert_that(user.is_staff, is_(True))\n    assert_that(user.is_superuser, is_(True))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promocode_available_only_for_washing(self) -> None:\n    self.client = AuthenticatedClient()\n    code = self.any_promo_code(\n        price=140,\n        infinite_use=True,\n        code_type=promo_code_type.global_type,\n        available=promo_code_availability.washing,\n    )\n    washing_deal = self.any_deal()\n    prepaid_account_deal = self.any_deal__credits_pack()\n    self.when_i_retrieve_promo_code(code.code, deal_id=washing_deal.id)\n    promo_code = self.last_response.data\n    fields = promo_code[\"fields\"]\n    self.assertTrue(fields[\"code\"])\n    self.assertEqual(fields[\"code\"], code.code)\n    self.when_i_retrieve_promo_code(code.code, deal_id=prepaid_account_deal.id)\n    self.then_http_status_is(404)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_issue(self) -> None:\n    s1 = self.any_site()\n    s2 = self.any_site()\n    self.client = AuthenticatedClient(sites=[s1, s2])\n    data = self.any_json_filter()\n    RequestListPage.get(client=self.client, site_slug=s1.slug, data=data)\n    RequestListPage.get(client=self.client, site_slug=s2.slug)\n    s1_filter_model_pk = self.client.session[f\"{str(s1.pk)}_request_filters_pk\"]\n    s2_filter_model_pk = self.client.session[f\"{str(s2.pk)}_request_filters_pk\"]\n    assert_that(s1_filter_model_pk, not_(empty()))\n    assert_that(s2_filter_model_pk, not_(empty()))\n    assert_that(s1_filter_model_pk, not_(s2_filter_model_pk))\n    s1_filter_model = RequestFilterModel.objects.filter(pk=s1_filter_model_pk).first()\n    s2_filter_model = RequestFilterModel.objects.filter(pk=s2_filter_model_pk).first()\n    assert_that(s1_filter_model, not_none())\n    assert_that(s1_filter_model.state, contains_inanyorder(*data[\"state\"]))\n    assert_that(s1_filter_model, not_none())\n    assert_that(s2_filter_model.state, empty())\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_vehicle_models_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    vehicle_model = self.any_vehicle_model()\n    self.when_i_list_vehicle_model(brand_pk=vehicle_model.vehicle_brand.pk)\n\n    assert_that(self.last_response, http(200))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_order__publish_kleen_coupon(self) -> None:\n    \"\"\"\n    Given an order with\n        - a deal for a washing program\n    When I complete this order\n    Then the kleen coupon is published\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)\n\n    with mock.patch(\"kleen.carwash.bus.adapters.coupon.KleenCoupon.publish\") as m:  # noqa: RMS102\n        self.any_order(user=user, payment_method=payment_methods.mangopay, cart=cart)\n    m.assert_called_once()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_serialize_cond_not_implemented_condition(self) -> None:\n    \"\"\"\n    Given a driver climax scenario codec\n    When i serialize condition witho bad condtion\n    Then i have a not implemented error\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_decoder = self.any_driver_codec(hss.driver)\n    assert_that(calling(driver_decoder._serialize_cond).with_args(1), raises(NotImplementedError))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_carriage__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_step().request\n    assert_that(request.version == request_version)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_read_me_with_access_field(self) -> None:\n    self.when_i_read_me()\n    data_contract = self.json_content[\"fields\"][\"contract_set\"][0]\n    assert_that(data_contract[\"fields\"][\"access\"], is_(not_none()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_authentication__get_user__unknon(self) -> None:\n    user = MyRoadBackend().get_user(user_id=uuid.uuid4())\n\n    assert_that(user, none())\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_states(self) -> None:\n    for state in cp_scheduler_states.all:\n        with self.subTest(state=state):\n            cp_scheduler = self.any_credits_pack_scheduler(state=state)\n            assert_that(cp_scheduler.state, is_(state))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_is_specific__height(self) -> None:\n    request = self.any_request(state=request_states.draft, ready_to_submit=False)\n    pu = self.any_packaging_unit(request=request)\n    pu.size = \"1x1x401\"\n\n    assert_that(pu.is_specific, is_(True))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_phone_number_is_optional(self) -> None:\n    \"\"\"\n    Given request requester form data with no requester phone number\n    When I validate\n    Then request_requester is valid\n    \"\"\"\n    request = self.any_request(state=\"draft\")\n    request.requester_phone_number = \"\"\n    request.save()\n    request_requester_data = self.any_request_requester_form_data(request=request)\n    request_requester_form = make_requester_form(\n        instance=request, user=request.creator, read_only=False, action=form_actions.submit\n    )(instance=request, data=request_requester_data)\n    request_requester_form.is_valid()\n    assert_that(request_requester_form.is_valid(), is_(True))\n    assert_that(request_requester_form[\"requester_phone_number\"].data, is_(\"\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_change_power_switch_name(self) -> None:\n    power_switch_data = self.when_i_list_power_switches_for_hss(self.client.hss)[0]\n\n    self.when_i_change_power_switch_name(self.client.hss, power_switch_data[\"pk\"], name=\"Salon (test)\")\n\n    assert_that(self.last_response.status_code, is_(status.HTTP_204_NO_CONTENT))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_retreive_scenario_not_found(self) -> None:\n    \"\"\"\n    When I retreive scenario not in maia\n    Then NotFound\n    \"\"\"\n    assert_that(\n        calling(self.maia_scenario_driver.retreive_scenario).with_args(\n            maia_scenario=MaiaScenario(\n                uuid=UUID(\"2eb28e47-6794-4f01-a5c8-541e2258fe76\"),\n            )\n        ),\n        raises(NotFound),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promotional_offer_discounted_multiple_remove_required(self) -> None:\n    \"\"\"\n    Given a cart with promotional offer for a discounted item having two items\n    When I remove a required item\n    Then\n        One discounted item is left\n        One required item is left\n        One not discounted item is created\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_required = cart.cartitem_set.filter(deal=required_deal).first()\n    assert_that(cart_item_required, is_not(None))\n    self.remove_item(cart, cart_item_required)\n    assert_that(cart.cartitem_set.count(), is_(3))\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_(1))\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    cart_item_3 = cart.cartitem_set.filter(deal=discounted_deal.washing_program.best_deal).first()\n    assert_that(cart_item_3, is_not(None))\n    assert_that(cart_item_3.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": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_best_deals(self) -> None:\n    \"\"\"\n    Given washing program with multiple deals per vehicle types\n    When I get best deals\n    Best deals contains the best deal for each vehicle type\n    \"\"\"\n    washing_program = self.any_washing_program()\n    deal_1 = self.any_deal(\n        washing_program=washing_program,\n        vehicle_sizes=[VehicleSize.CITY, VehicleSize.COMPACT],\n        price_after_discount=Decimal(\"10.0\"),\n        price_before_discount=Decimal(\"11.0\"),\n    )\n    deal_2 = self.any_deal(\n        washing_program=washing_program,\n        vehicle_sizes=[VehicleSize.CITY, VehicleSize.SUV_4X4],\n        price_after_discount=Decimal(\"11.0\"),\n        price_before_discount=Decimal(\"12.0\"),\n    )\n    self.any_deal(\n        washing_program=washing_program,\n        vehicle_sizes=[VehicleSize.COMPACT, VehicleSize.SUV_4X4],\n        price_after_discount=Decimal(\"12.0\"),\n        price_before_discount=Decimal(\"12.0\"),\n    )\n\n    best_deals = washing_program.best_deals\n    assert_that(len(best_deals), is_(2))\n    assert_that(\n        best_deals,\n        contains_inanyorder(\n            has_properties(\n                {\n                    \"pk\": is_(deal_1.pk),\n                    \"vehicle_sizes\": contains_inanyorder(VehicleSize.CITY, VehicleSize.COMPACT),\n                }\n            ),\n            has_properties({\"pk\": is_(deal_2.pk), \"vehicle_sizes\": contains(VehicleSize.SUV_4X4)}),\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_booking(self) -> None:\n    \"\"\"\n    Given a booking with purchase\n    When I complete checkout\n    Then order has been created and is succeeded, checkout is ordered, cart is checked_out\n    \"\"\"\n    user = self.any_user(with_billing_info=True, with_total_gr_card=True)\n    self.any_user_vehicle(user=user)\n    booking = self.any_real_booking(with_purchase=True)\n    booking.station.operator = self.any_seller(seller_type=seller_types.tmf, with_funds=True)\n    booking.station.save()\n    cart = self.any_cart(\n        user=user, profile=cart_profiles.booking_purchase, booking=booking, state=cart_states.active\n    )\n    checkout = self.any_checkout(cart=cart, state=checkout_states.ready, payment_method=self.PAYMENT_METHOD)\n    with transaction.atomic():\n        order = checkout.complete()\n    booking.refresh_from_db()\n    responses = Request.objects.wait_for_responses()\n    [response.raise_for_status for response in responses]\n    while order.status not in order_states.purchase_final:\n        with transaction.atomic():\n            order.refresh()\n            order.refresh_from_db()\n    assert_that(checkout.state, is_(checkout_states.ordered))\n    assert_that(checkout.cart.state, is_(cart_states.checked_out))\n    assert_that(checkout.order_id, not_none())\n    assert_that(order.status, is_(order_states.success))\n    booking.refresh_from_db()\n    assert_that(booking.state, is_(booking_states.confirmed))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_client_raises_panel_send_sms_failed_on_honeywell_200(self) -> None:\n    hss = self.any_configured_hss(account=default_honeywell_account)\n    hss.has_ip = False\n    hss.save()\n    client = Client(hss)\n    with requests_mock.Mocker(real_http=True) as m:\n        m.get(self._mock_url, json={\"messageKey\": \"domoweb.pe.sendsms6.failed\", \"errorCode\": 7})\n        assert_that(\n            calling(client._request).with_args(url=self._mock_url, should_retry=False), raises(PanelSendSMSFailed)\n        )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_initial__pickup_address_default(self) -> None:\n    \"\"\"\n    Given:\n        - any site\n        - with request_type with pickup default address\n    When i have create a request\n    Then first step address is equal to pickup default address\n    \"\"\"\n    site = self.any_site(with_request_type=True)\n    address = self.any_address(with_site=site)\n    request_type_framed = site.requesttype_set.filter(name=\"framed\").first()\n    request_type_framed.pickup_default = address\n    request_type_framed.save()\n\n    user = self.any_user(sites=[site.pk])\n    request = Request.objects.initial(site=site, creator=user, type=request_types.framed)\n    step = request.steps.filter(position=0).first()\n    assert_that(\n        step,\n        has_properties(\n            {\n                \"address_name\": address.name,\n                \"address_1\": address.address_1,\n                \"address_2\": address.address_2,\n                \"postal_code\": address.postal_code,\n                \"city\": address.city,\n                \"country\": address.country,\n                \"contact\": address.default_contact,\n                \"comment\": address.default_comment,\n                \"timezone\": address.timezone,\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_cart_item_product_voucher__affected_by_promocode(self) -> None:\n    \"\"\"\n    Given a user with\n        - An empty cart\n        - A product voucher for product P1\n        - A deal affected by a promocode\n    When I add a washing program for product P1 to the cart\n    Then the cart have a deal without product voucher\n    \"\"\"\n    self.any_product_voucher(\n        product=self.product, product_voucher_account=self.user.product_voucher_account_set.first()\n    )\n    cart = self.any_cart(state=cart_states.empty, user=self.user, with_promocode=True)\n\n    cart.add_item(deal=self.deal)\n\n    deal = cart.cartitem_set.first().deal\n    assert_that(deal.product_voucher, is_(none()))\n", "output": "3"}
{"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 incorrect values\n    When I encode this scenario\n    Then i get an exception describing the value which is incorrect\n    \"\"\"\n    contract = ContractMixin().any_honeywell_contract(contract_number=digital_alchon_account.contract_numbers[0])\n    hss = HssMixin().any_hss(user=contract.user, contract=contract, remote_proxy=remote_proxies.honeywell)\n    condition = PanelStatusConditionHoneywell(\"nok\", condition_types.panel_status)\n    scenario_info = self.any_scenario_info(driver=hss.driver, condition=condition)\n    scenario = self.any_scenario(hss, state=states.draft, scenario_info=scenario_info, save=False)\n    driver_decoder = self.any_driver_codec(hss.driver)\n    with self.assertRaises(serializers.ValidationError) as e:\n        driver_decoder.encode(scenario)\n    assert_that(e.exception.detail, has_entry(\"condition\", not_none()))\n    assert_that(e.exception.detail[\"condition\"], has_entry(\"status\", not_none()))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_name(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with Honeywell panel\n        - a HssDriver\n    When:\n        - I update name of ir detector\n    Then:\n        - I get a NotImplementedError\n    \"\"\"\n    hss = self.any_configured_hss(account=default_honeywell_account)\n    driver = driver_factory.get_driver(hss=hss)\n    new_name = get_random_string(15)\n    assert_that(\n        calling(driver.ir_detectors.update_name).with_args(device_id=\"test\", new_name=str(new_name)),\n        raises(NotImplementedError),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_queryset__idea_supervisor(self) -> None:\n    \"\"\"\n    Given:\n        - u1 a user with role idea_supervisor\n        - u2 a user not in same team as u1\n        - u3 a user in same team as u1\n        - t1 a team with u1 and u2\n        - r1 request created by u1\n        - r2 request created by u2\n        - r3 request created by u2 in same site\n        - r4 request created by u3\n    When I get request queryset with u1\n    Then r1 , r3, r4 returned\n    \"\"\"\n    s2 = self.any_site()\n    u1 = self.any_user(roles=[permission_roles.idea_supervisor], sites=[self.site.uuid])\n    u2 = self.any_user(sites=[self.site.uuid, s2.uuid])\n    u3 = self.any_user(sites=[self.site.uuid])\n    self.any_team(with_users=[u1, u3])\n    r1 = self.any_request(site=self.site, creator=u1)\n    self.any_request(site=s2, creator=u2)\n    r3 = self.any_request(site=self.site, creator=u2)\n    r4 = self.any_request(site=self.site, creator=u3)\n    queryset = RequestQuerySet(site=self.site, user=u1).make()\n    assert_that(queryset, contains_inanyorder(r1, r3, r4))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__not_found(self) -> None:\n    site = self.any_site()\n    with self.assertRaises(NotFoundException):\n        RequestActionPage.get(client=self.client, site_slug=site.slug, pk=uuid.uuid4())\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_code_for_hss_when_label_contains_too_much_characters(self) -> None:\n    \"\"\"\n    Given any hss\n    Given a label > 30 chars\n    When I update the code and serialize it\n    Then return a 400 with a specific error message\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.honeywell)\n    code = self.any_honeywell_code()\n    serializer = UpdateCodeSerializer(\n        data={\n            \"index\": f\"1_{code.index}\",\n            \"code\": \"B456\",\n            \"label\": \"0123456789012345678901234567890\",  # 31 characters\n        },\n        context={\"hss\": hss},\n    )\n    with self.assertRaises(APIException) as e:\n        serializer.is_valid(raise_exception=True)\n\n    assert_that(e.exception.status_code, is_(status.HTTP_400_BAD_REQUEST))\n    assert_that(\n        e.exception.detail,\n        has_entry(\n            \"label\", has_item(contains_string(\"Assurez-vous que ce champ comporte au plus 30\\xa0caractères.\"))\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve__anonymous(self) -> None:\n    \"\"\"\n    Given an anonymous user\n    When I retrieve\n    Then 200\n    \"\"\"\n    self.client = AnonymousClient()\n    campaign = self.any_promotional_campaign()\n\n    self.when_i_retrieve_promotional_campaign(campaign_id=campaign.pk)\n\n    assert_that(self.last_response, http(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_activate_promotional_offer__greater_than_today(self) -> None:\n    \"\"\"\n    Given any promotional offer not active and validity_from greater than today\n    When I launch activate_promotional_offer_on_date task\n    Then promotional offer is still not active\n    \"\"\"\n    date = timezone.now().date()\n\n    promotional_offer = self.any_promotional_offer(active=False)\n    promotional_offer.validity_from = date + timedelta(days=1)\n    promotional_offer.save()\n\n    activate_promotional_offer_on_date()\n\n    promotional_offer.refresh_from_db()\n    assert_that(promotional_offer.active, is_(False))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve__not_found(self) -> None:\n    user = self.any_user()\n    site = self.any_site()\n    self.client = AuthenticatedClient(user=user)\n    self.when_i_get_address(site_slug=site.slug, id=\"test\")\n    assert_that(self.last_response.status_code, is_(status.HTTP_404_NOT_FOUND))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__not_found(self) -> None:\n    \"\"\"\n    given unknown request pk\n    when loading the page\n    then not found exception is thrown\n    \"\"\"\n    pk = uuid.uuid4()\n    site = self.any_site()\n    with self.assertRaises(NotFoundException):\n        RequestRefusePage.get(client=self.client, site_slug=site.slug, pk=pk)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_resynchro_task_for_contract(self) -> None:\n    hss = self.any_hss()\n    task = 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\": task.hss.site.contract.contract_number})\n    assert_that(response.status_code, is_(200), response.content)\n    assert_that(\n        response.json(),\n        only_contains(\n            has_entries(\n                {\n                    \"pk\": task.id,\n                    \"model\": \"scenarios.resynchro-task\",\n                    \"fields\": has_entries(\n                        {\n                            \"state\": resynchro_task_states.pending,\n                            \"source\": resynchro_task_sources.private_api,\n                            \"creation_time\": task.creation_time.astimezone().isoformat(),\n                            \"error_message\": \"\",\n                        }\n                    ),\n                }\n            )\n        ),\n    )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_first_credit_pack__increased_bonus__prices__fail(self) -> None:\n    \"\"\"\n    Given any first_credit_pack promocode and increased bonus\n    When I use it\n    Then orderitem has:\n        - price_before_discount not equal to corrected_price_before_discount\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_promocode(profile=promocode_profiles.v2_first_credits_pack_purchase, version=2)\n    product = self.any_product_lazy()\n    PromoCodeCreditsPackProduct.objects.create(credits_pack=credits_pack, product=product)\n\n    deal = self.any_deal(\n        profile=deal_profiles.credits_pack,\n        credits_pack=credits_pack,\n        price_after_discount=decimal.Decimal(\"10\"),\n        price_before_discount=decimal.Decimal(\"15\"),\n    )\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.add_item(deal=deal)\n    cart.update(promocode=promocode)\n\n    checkout = self.any_checkout(\n        cart=cart,\n        payment_method=payment_methods.mangopay,\n        state=checkout_states.ready,\n        with_ip_address=True,\n        with_browser_info=True,\n    )\n    order = Order.objects.create_with_checkout(checkout)\n    order.change_to_failed()\n    assert order.status == order_states.failed\n    assert_that(order.promocode_type, is_(\"first_credits_pack_purchase\"))\n    assert_that(order.offer_type, is_(\"increased_bonus\"))\n\n    orderitem = order.orderitem_set.get()\n    assert_that(orderitem.price_before_discount, not_(orderitem.corrected_price_before_discount))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(USE_PROMOCODE_PREFIX_NF0=False)\ndef test_find_promocode_with_promocode_prefix_not_active__correct_code(self) -> None:\n    \"\"\"\n    Given a\n        cart\n        promocode with an NF0 code\n        settings USE_PROMOCODE_PREFIX_NF0 NOT active\n    When I search for a promocode with the full code\n    Then I find it and I get an http response with a status code 200\n    \"\"\"\n    self.client = AuthenticatedClient()\n    promocode = self.any_promocode(\n        version=2,\n        profile=promocode_profiles.v2_first_credits_pack_purchase,\n        code=\"NF099225\",\n    )\n    cart = self.any_cart(state=cart_states.active, api_version=API_VERSION)\n    self.when_i_search_promocode(cart=cart, code=promocode.code)\n\n    assert_that(self.last_response, http(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_partitions__prom_code_error(self) -> None:\n    \"\"\"\n    Given any hss with prom_code : 9999\n    When I list partitions\n    Then I get an http error\n    \"\"\"\n    hss = self.any_hss(remote_proxy=remote_proxies.hik, prom_code=\"9999\")\n\n    with self.assertRaises(DriverException):\n        self.when_i_list_paritions(hss)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_event_adapter_interface(self) -> None:\n    adapter = EventAdapter()\n    event = DummyEvent()\n    assert_that(calling(adapter.as_data).with_args(event), raises(NotImplementedError))\n    assert_that(calling(adapter.exchange).with_args(event), raises(NotImplementedError))\n    assert_that(calling(adapter.topic).with_args(event), raises(NotImplementedError))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_add_credits_to_fleet_prepaid_accounts_without_bill__not_fleet_owner(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    self.when_i_add_credits_to_fleet_prepaid_accounts_without_bill(ids=[fleet_prepaid_account.pk])\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer(self) -> None:\n    \"\"\"\n    Given any charter with users and sites\n    When I serialized it\n    Then I get valid json representation\n    \"\"\"\n    charter = self.any_charter(with_users=True)\n    assert charter.sites.count() != 0\n    data = CharterSerializer(instance=charter).data\n    users_matcher = [user.myroad_uri.value for user in charter.users.all()]\n    sites_matcher = [site.myroad_uri.value for site in charter.sites.all()]\n    assert_that(\n        data,\n        has_entries(\n            {\n                \"name\": is_(charter.name),\n                \"code\": is_(charter.code),\n                \"slug\": is_(charter.slug),\n                \"active\": is_(charter.active),\n                \"users\": contains_inanyorder(*users_matcher),\n                \"sites\": contains_inanyorder(*sites_matcher),\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_icon__new_icons(self) -> None:\n    \"\"\"\n    Given\n        - a Hss with an Essentielle panel\n        - a HssDriver\n        - a climax powerswitch\n    When\n        - I update powerswitch icon with\n            a led, strip, outdoor, plug icons\n    Then\n        - I get a powerswitch with these icons\n    \"\"\"\n    hss = self.any_configured_hss(account=papillon_essentielle_account)\n    driver = driver_factory.get_driver(hss)\n    powerswitch = self.any_essentielle_powerswitch(hss=hss)\n\n    assert_that(\n        driver.power_switches.update_icon(device_id=powerswitch.zigbee_id, new_icon=\"led\").icon,\n        is_(power_switch_icons.led),\n    )\n    assert_that(\n        driver.power_switches.update_icon(device_id=powerswitch.zigbee_id, new_icon=\"strip\").icon,\n        is_(power_switch_icons.strip),\n    )\n    assert_that(\n        driver.power_switches.update_icon(device_id=powerswitch.zigbee_id, new_icon=\"outdoor\").icon,\n        is_(power_switch_icons.outdoor),\n    )\n    assert_that(\n        driver.power_switches.update_icon(device_id=powerswitch.zigbee_id, new_icon=\"plug\").icon,\n        is_(power_switch_icons.plug),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list_policies_to_accept__never_accepted(self) -> None:\n    \"\"\"\n    Given a policy, an authenticated user wich never accepted policies\n    When I list policies to accept\n    Then I get a response with a status code 200, a list with a policy\n    \"\"\"\n    policy = self.any_policy(tos_type=TosType.KLEEN_TOU)\n    self.when_i_list_policies_to_accept()\n    assert_that(self.last_response, http(200))\n    assert_that(self.last_response.json(), has_length(1))\n    assert_that(\n        self.last_response.json()[0],\n        has_entries({\"model\": \"policy.policy\", \"fields\": not_none(), \"pk\": is_(policy.model_pk)}),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cancel__anonymous(self) -> None:\n    self.client = AnonymousClient()\n    self.when_i_cancel_checkout(checkout_id=1234)\n\n    assert_that(self.last_response, http(403))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_global_promo_code_passed_and_no_expiration(self) -> None:\n    user = self.any_user()\n    promocode = self.any_promo_code_passed_no_expiration(user)\n\n    self.when_i_fetch_specific_promo_codes_for_user(user, promocode.code)\n    self.then_there_are_n_promocodes(1)\n    self.when_i_fetch_listed_promo_codes_for_user(user)\n    self.then_there_are_n_promocodes(1)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_retrieve__anonymous(self) -> None:\n    \"\"\"\n    Given an anonymous user\n    When I retrieve\n    Then 200\n    \"\"\"\n    self.client = AnonymousClient()\n    deal = self.any_deal(profile=deal_profiles.credits_pack)\n    self.when_i_retrieve_credits_packs(credits_pack_id=deal.credits_pack.id)\n\n    assert_that(self.last_response, http(200))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(CACHES=TEST_NO_CACHES, DISABLE_REDLOCK=True)\n@vcr.use_cassette()\ndef test_unpublish_scenario(self) -> None:\n    \"\"\"\n    Given : A scenario with is_on = True\n    When : I unpublish this scenario\n    Then : I get a 200 HTTP response\n            The scenario has been updated with is_on = False\n            The scenario state is ready\n    \"\"\"\n    last_response = self.when_i_unpublish_scenario(self.initial_scenario.pk)\n    self.initial_scenario.refresh_from_db()\n    assert_that(last_response.status_code, is_(200))\n    assert_that(last_response.json(), not_none())\n    assert_that(last_response.json()[\"fields\"], not_none())\n    assert_that(last_response.json()[\"fields\"][\"state\"], is_(states.ready))\n    assert_that(self.initial_scenario.is_on, is_(False))\n    assert_that(self.initial_scenario.state, is_(states.ready))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_old_password_valid(self) -> None:\n    \"\"\"\n    Given user with a password,\n    When i validate a new password,\n    The validation passes\n    \"\"\"\n    user = self.any_user(with_consumer=False)\n    validator = OldPasswordValidator()\n    call = calling(validator.validate).with_args(password=\"plop\", user=user)\n    assert_that(call, not_(raises(ValidationError)))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_issue_is_fixed(self) -> None:\n    user = self.any_user(with_mobile_phone_verified=True)\n    user_2 = self.any_user(with_mobile_phone_verified=False)\n    user_2.mobile_phone = user.mobile_phone\n    user_2.mobile_phone_is_verified = True\n    with self.assertRaises(IntegrityError) as e:\n        user_2.save()\n    assert_that(e.exception.args[0], contains_string(\"unique_mobile_phone_when_verified\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form_off_valid(self) -> None:\n    data = {\n        \"status\": \"0\",  # off\n    }\n\n    form = PanelStatusConditionForm(data=data)\n    is_valid = form.is_valid()\n    result = form.to_model(instance_pk=1)\n\n    self.assertTrue(is_valid)\n    self.assertEqual(result.status, \"off\")\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_load__not_found(self) -> None:\n    site = self.any_site()\n    with self.assertRaises(NotFoundException):\n        RequestRefuseQuotePage.get(client=self.client, site_slug=site.slug, pk=uuid.uuid4())\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_error__no_payment(self) -> None:\n    order = self.any_order(\n        with_full_prepaid_account=True, refundable=True, payment_method=payment_methods.prepaid_account_mangopay\n    )\n    issue = self.any_issue(order=order, state=states.completed)\n    data = {\"price_incl_tax\": 5, \"prepaid_price_incl_tax\": 2}\n    form = PartialRefundForm(issue=issue, data=data)\n    assert_that(form.is_valid(), is_(False))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_vehicle_model_str(self) -> None:\n    vehicle = self.any_vehicle_model()\n    assert_that(str(vehicle), instance_of(str))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cart__update__promocode__offered_product(self) -> None:\n    \"\"\"\n    Given\n        a cart\n        a promocode offering a product\n    When i update cart\n    Then a cart item has been added linked to a deal type offered washing\n    \"\"\"\n    station = self.any_station()\n    washing_program_to_be_offered = self.any_washing_program(station=station)\n    purchased_washing_program = self.any_washing_program(station=station)\n    deal = self.any_deal(washing_program=purchased_washing_program)\n    promocode = self.any_promocode(\n        profile=promocode_profiles.v2_offered_product,\n        version=2,\n        product_to_offer=washing_program_to_be_offered.product,\n    )\n    cart = self.any_cart(profile=cart_profiles.deal_washing, state=cart_states.active, deal=deal)\n\n    cart.update(promocode=promocode)\n\n    assert_that(cart.state, is_(cart_states.active))\n    assert_that(cart.offered_cartitems, has_length(1))\n    assert_that(cart.offered_cartitems.first().deal.type, is_(deal_types.offered_washing))\n    assert_that(cart.offered_cartitems.first().deal.washing_program, is_(washing_program_to_be_offered))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_should_synchronize_mangopay_user(self) -> None:\n    \"\"\"\n    Given any user\n    When i launch task should_synchronize_mangopay_user\n    Then cache key has been set\n    \"\"\"\n    user = self.any_user()\n    user.create_mp_user_if_needed()\n    tasks.should_synchronize_mangopay_user(user.mp_user.pk)\n    assert_that(cache.get(f\"mp_{user.mp_user.pk}_is_dirty\", None), not_none())\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_clean_empty_deal_reference__request_from_specified_state__is_ok(self) -> None:\n    request = self.any_request(state=request_states.draft)\n    step = request.steps.filter(type=step_types.deliver).first()\n    assert step\n    step.deal_reference = \"\"\n    step.full_clean()\n    step.save()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_get_rating_hss_with_delegation(self) -> None:\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    response = self.when_i_get_rating(hss_pk=hss.pk)\n    assert_that(response.status_code, is_(200))\n    assert_that(response.json(), has_length(3))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_from_generic(self) -> None:\n    capture = self.any_local_essentielle_capture()\n    assert_that(Capture.objects.from_generic(capture.to_generic()), is_(capture))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promo_code__invalid_type_for_version(self) -> None:\n    \"\"\"\n    Given a v2 promocode with type cart_discount_percentage\n    When I try to set version to 1\n    Then it raise an ValidationError exception\n    \"\"\"\n    promo_code = self.any_promocode(version=2, profile=promocode_profiles.v2_cart_discount_percentage)\n    promo_code.version = 1\n    with self.assertRaises(ValidationError) as e:\n        promo_code.clean()\n    assert_that(\n        e.exception.args[0],\n        is_(\"Le type de code cart_discount_percentage n'est pas disponible pour la version 1.\"),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_without_refuse_reason(self) -> None:\n    \"\"\"\n    given any quoted request in 3rd_party_transmission state\n    given any form without refuse reason\n    when validating the form\n    then errors are thrown and contain the key \"refuse_reason\"\n    \"\"\"\n    request = self.any_quoted_request(state=request_states._3rd_party_transmission)\n    form = self.any_refuse_form(request, refuse_reason=None)\n    form.is_valid()\n    assert_that(form.errors, has_entry(\"refuse_reason\", not_(empty())))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_full_clean_issue__partial_refunc_both_0(self) -> None:\n    user = self.any_user(mangopay_card=mangopay_cards.normal)\n    order = self.any_order(\n        refundable=True,\n        user=user,\n        with_full_prepaid_account=True,\n        payment_method=payment_methods.prepaid_account_mangopay,\n    )\n    order.sold_price = 4\n    order.prepaid_account_used_incl_vat = 3\n\n    issue = self.any_issue(order=order, state=states.waiting_for_action)\n    with self.assertRaises(ValidationError) as e:\n        issue.refund(partial_refund_price_incl_tax=0, partial_refund_prepaid_price_incl_tax=0)\n    assert_that(e.exception.message_dict, has_key(\"partial_refund_prepaid_price_excl_tax\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_offered_product__corrected_prices__discount_limit__valid_product(self) -> None:\n    \"\"\"\n    Given any order with product voucher\n    Then promocode_type is product_discount\n    \"\"\"\n    user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n    product = self.any_product()\n    wp = self.any_washing_program(product=product)\n    promocode = self.any_promocode(profile=promocode_profiles.v2_cart_discount_percentage, version=2)\n    promocode.discount_percentage = 100\n    promocode.rules.append(promo_code_rules.valid_for_a_certain_ammount)\n    promocode.rules.append(promo_code_rules.valid_for_any_product_purchase)\n    promocode.discount_limit = 2\n    promocode.save()\n    promocode.products.add(product)\n\n    deal = self.any_deal(\n        washing_program=wp,\n        price_before_discount=decimal.Decimal(5),\n        price_after_discount=decimal.Decimal(5),\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    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    orderitem = order.orderitem_set.get()\n    assert_that(orderitem.corrected_price_after_discount, is_(3))\n    assert_that(orderitem.price_after_discount, not_(orderitem.corrected_price_after_discount))\n    assert_that(orderitem.price_before_discount, is_(orderitem.corrected_price_before_discount))\n    assert_that(order.discount, is_(2))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(NEED_DEFAULT_PROMOCODE=True)\ndef test_create__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__null_values(self) -> None:\n    climax_json = load(\"climax_kiz_scenario_list.json\")\n    climax_json[\"has\"][\"ha\"][0][\"rule\"] = None\n    serializer = ListResponseSerializer(data=climax_json)\n    with self.assertRaises(ValidationError):\n        serializer.is_valid(raise_exception=True)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_serialize_scenario_create__action_take_picture_all_cameras(self) -> None:\n    \"\"\"\n    Given : Scenario data, with an action take_picture_all_cameras\n    When : I serialize this data, and create the corresponding scenario\n    Then : I get a new Scenario, corresponding to the data i gave\n    \"\"\"\n    hss = self.client.hss\n    driver = hss.driver\n    action = self.any_action(action_types.take_camera_picture, driver, {\"device_pk\": None})\n    info = self.any_scenario_info(\n        driver=driver,\n        actions=[\n            action,\n        ],\n    )\n    scenario = self.any_scenario(hss=hss, scenario_info=info, save=False)\n    data = self.any_scenario_data(scenario)\n    # data['actions'] = [{'type': action_types.take_camera_picture, 'fields': {'device_pk': None}}]\n    serializer = CreateUpdateScenarioSerializer(data=data, context={\"hss\": hss, \"driver\": driver.scenarios})\n    serializer.is_valid(raise_exception=True)\n    serializer.create()\n    assert_that(Scenario.objects.all(), has_length(1))\n    scenario = Scenario.objects.all().first()\n    assert_that(scenario.info.actions, has_length(1))\n    action = scenario.info.actions[0]\n    assert_that(action.device_pk, is_(none()))\n    assert_that(action.zone, is_(none()))\n", "output": "2"}
{"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\n    request_permissions_without_cancel = [\n        perm for perm in request_permissions.all if perm != request_permissions.can_cancel\n    ]\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_without_cancel:\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_clean_task_session_noclean(self) -> None:\n    \"\"\"\n    Given any filter with session_time > now - creation time\n    When i call clean_session_filter task\n    Then filter is still there\n    \"\"\"\n    request_filter = self.any_request_filter(filter_type=FilterType.SESSION)\n    with now(timezone.now()):\n        request_filter.save()\n    clean_session_filter()\n    assert_that(RequestFilterModel.objects.all().count(), equal_to(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promocode_send_on_save(self) -> None:\n    promocode = self.any_promocode()\n    with mock.patch(\"tw.replication.client.publish\") as m:  # noqa: RMS102\n        promocode.save()\n    m.assert_called_once()\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_charter_plan(self) -> None:\n    request = self.any_quoted_request(state=request_states._3rd_party_transmission, creator=self.client.user)\n    page = RequestActionPage.get(\n        client=self.client, site_slug=request.site.slug, pk=request.pk\n    ).form.charter_plan()\n    assert_that(page, instance_of(RequestCharterPlanPage))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@with_mango_mocks()\ndef test_buy_deal__mocked(self) -> None:\n    \"\"\"\n    Given\n        a deal\n        a user with 3DS card\n    When i buy deal\n    Then order is success\n    \"\"\"\n    user = self.any_user(\n        mangopay_card=mangopay_cards.secure, secure_mode_version=secure_mode_versions.secure_mode_3ds2\n    )\n    deal = self.any_deal()\n\n    order = self.when_i_buy(deal=deal, user=user, payment_method=payment_methods.mangopay)\n\n    transaction = order.transaction.wait_for_completion()\n    order.refresh_from_db()\n\n    assert_that(transaction.state, is_(transaction_states.success))\n    assert_that(order.status, is_(order_states.success))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_change_power_switch_icon(self) -> None:\n    power_switch_data = self.when_i_list_power_switches_for_hss(self.client.hss)[0]\n    new_icon = \"light\" if power_switch_data[\"fields\"][\"icon\"] == \"toy\" else \"toy\"\n\n    self.when_i_update_power_switch_icon(self.client.hss.pk, power_switch_data[\"pk\"], new_icon)\n\n    assert_that(self.last_response.status_code, is_(status.HTTP_204_NO_CONTENT))\n    self.then_power_switch_icon_is(self.client.hss, power_switch_data[\"pk\"], new_icon)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_cart_item_update_form__no_quantity(self) -> None:\n    cart = self.any_cart(state=cart_states.active)\n    cart_item = cart.cartitem_set.first()\n    form = CartItemUpdateForm({\"quantity\": 0}, context={\"item\": cart_item})\n    assert_that(form.is_valid(), is_(False))\n    assert_that(form.errors, has_entry(\"quantity\", is_(not_none())))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_queryset__manager(self) -> None:\n    \"\"\"\n    Given:\n        - u1 a user with role manager\n        - u2 a user not in same team as u1\n        - u3 a user in same team as u1\n        - t1 a team with u1 and u2\n        - r1 request created by u1\n        - r2 request created by u2\n        - r3 request created by u2 in same site\n        - r4 request created by u3\n    When I get request queryset with u1\n    Then r1 , r3, r4 returned\n    \"\"\"\n    s2 = self.any_site()\n    u1 = self.any_user(roles=[permission_roles.manager], sites=[self.site.uuid])\n    u2 = self.any_user(sites=[self.site.uuid, s2.uuid])\n    u3 = self.any_user(sites=[self.site.uuid])\n    self.any_team(with_users=[u1, u3])\n    r1 = self.any_request(site=self.site, creator=u1)\n    self.any_request(site=s2, creator=u2)\n    r3 = self.any_request(site=self.site, creator=u2)\n    r4 = self.any_request(site=self.site, creator=u3)\n    queryset = RequestQuerySet(site=self.site, user=u1).make()\n    assert_that(queryset, contains_inanyorder(r1, r3, r4))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_uri_bad_scheme(self) -> None:\n    \"\"\"\n    Given any file uri with bad scheme\n    Then ValidationError is raised\n    \"\"\"\n    with self.assertRaises(ValidationError):\n        FileUri(\"anyscheme://hostname/path/to/specific/file.txt\")\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_checkout__missing_vehicle_to_ready(self) -> None:\n    \"\"\"\n    Given a TWIP free checkout in pending state\n    When I refresh checkout\n    Then checkout is ready and valid\n    \"\"\"\n    user = self.any_user()\n    checkout = self.any_checkout(\n        user=user, state=checkout_states.pending, payment_method=payment_methods.twip_free\n    )\n    with transaction.atomic():\n        checkout.refresh(consumer=checkout.cart.user.consumer_set.first())\n    assert_that(checkout.state, equal_to(checkout_states.missing_vehicle))\n    self.any_user_vehicle(user=user)\n    with transaction.atomic():\n        checkout.refresh(consumer=checkout.cart.user.consumer_set.first())\n    assert_that(checkout.state, equal_to(checkout_states.ready))\n    assert_that(checkout.order_id, none())\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_columns_to_export__invoice_reference__label(self) -> None:\n    \"\"\"\n    Given\n        a site configuration for invoice_reference definition\n        a request export setting with invoice_reference to export\n    When I get columns_to_export\n    Then a dict that contain custom label is return\n    \"\"\"\n    site = self.any_site()\n    user = self.any_user(sites=[site.pk])\n    invoice_reference_definition = Definition.objects.get(name=\"request.invoice_reference\")\n    conf = self.any_site_configuration(definition=invoice_reference_definition, site=site)\n    conf.label = \"CustomLabel\"\n    conf.full_clean()\n    conf.save()\n    with activate(site=site):\n        assert_that(p_(name=\"request.invoice_reference\").label == \"CustomLabel\")\n        export_setting = self.any_request_export_setting(\n            creator=user, site=site, fields_to_export=[\"invoice_reference\"]\n        )\n        assert_that(export_setting.columns_to_export, has_length(1))\n        assert_that(export_setting.columns_to_export[\"invoice_reference\"], is_(\"CustomLabel\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_delete_from_remote_and_local_given_remote_connection(self) -> None:\n    \"\"\"\n    Given any remote connection\n    When I delete it from remote and local\n    Then the connection is deactivate from remote\n    Then the connection is deleted from db\n    \"\"\"\n    connection = self.any_remote_connection()\n    connection_pk = connection.id\n    hss = connection.hss\n\n    connection.delete_from_remote_and_local()\n\n    list_connections = MaiaDriver(contract=hss.site.contract).list_connections(hss)\n    assert_that(list_connections, not_(has_item(has_property(\"id\", connection_pk))))\n    assert_that(\n        calling(Connection.objects.get).with_args(pk=connection_pk),\n        raises(Connection.DoesNotExist),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_infos_form__quoted__transport_services__required_shipping_charter(self) -> None:\n    \"\"\"\n     Given:\n        a quoted request in draft\n        request_infos form data with \"transport\" in services and no shipping_charter\n    When i validate form\n    Then form is valid and the widget associate to the field is hidden\n    \"\"\"\n    request = self.any_request(state=request_states.draft, type=request_types.quoted)\n    data = self.any_request_infos_form_data(request=request)\n    data[\"request_infos-shipping_charter\"] = \"\"\n    form = make_request_informations_form(instance=request, read_only=False, action=None)(\n        instance=request, data=data\n    )\n    assert_that(form.is_valid(), is_(False))\n    assert_that(form.errors, has_entry(\"shipping_charter\", anything()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_promocode_usable__percentage(self) -> None:\n    user = self.any_user()\n    promocode = PromoCode.objects.create_issue_percentage(\n        percentage=5, user=user, zone_context=self.any_zone_context()\n    )\n\n    is_valid = self.when_i_check_promocode_validity(promocode=promocode, user=user)\n    assert_that(is_valid, is_(False))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_repository(self) -> None:\n    \"\"\"\n    Given 1 zone_context and 1 brand associated with this zone_context\n    When I call the repository\n    Then I get 1 brand\n    \"\"\"\n    zone_context = self.any_zone_context()\n    self.any_brand(zone_context=zone_context)\n\n    filtered = BrandRepository().get_all(zone_context)\n\n    assert_that(len(filtered), is_(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_unknown_refuse_type(self) -> None:\n    \"\"\"\n    given any quoted request in 3rd_party_transmission state\n    given any form with unknown refuse type\n    when validating the form\n    then errors are thrown and contain the key \"refuse_type\"\n    \"\"\"\n    request = self.any_quoted_request(state=request_states._3rd_party_transmission)\n    form = self.any_refuse_form(request, refuse_type=\"unknown-refuse-type-for-sure\")\n    form.is_valid()\n    assert_that(form.errors, has_entry(\"refuse_type\", not_(empty())))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_begin__from_planned(self) -> None:\n    request = self.any_framed_request(state=request_states.planned)\n    with handle_shipping_record_notifications():\n        request = request.state_machine(user=request.creator).begin().request\n    request.refresh_from_db()\n    assert_that(request.state, is_(request_states.in_progress))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_str(self) -> None:\n    branding = self.any_branding()\n    assert_that(str(branding), is_(f\"Branding {branding.partner_name} [{branding.slug}]\"))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_form_valid_blind(self) -> None:\n    data = {\n        \"area\": \"1\",\n        \"zone\": \"2\",\n        \"status\": \"opened\",\n    }\n\n    form = CreateBlindActionForm(data=data)\n    is_valid = form.is_valid()\n\n    self.assertTrue(is_valid)\n    self.assertEqual(form.to_grammar(), \"a=1&z=2&sw=on\")\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_post_rating_hss_with_delegation(self) -> None:\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    data = self.any_rating_data()\n    last_response = self.when_i_post_rating(data, hss_pk=hss.pk)\n    assert_that(last_response.status_code, is_(204))\n    rating_action = RatingAction.objects.filter(os=data[\"os\"])\n    assert_that(rating_action, is_(not_none()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_buy_deal(self) -> None:\n    \"\"\"\n    Given a deal\n    When i buy\n    Then order is success\n    \"\"\"\n    deal = self.any_deal()\n    user = self.any_user(\n        mangopay_card=mangopay_cards.secure, secure_mode_version=secure_mode_versions.secure_mode_3ds2\n    )\n    with override_settings(SECURE_MODE_RETURN_URL=self.live_server_url):\n        order = self.when_i_buy(user=user, deal=deal, payment_method=payment_methods.mangopay)\n\n    transaction = order.transaction.wait_for_completion()\n    order.refresh_from_db()\n\n    assert_that(transaction.state, is_(transaction_states.success))\n    assert_that(order.status, is_(order_states.success))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_driver_factory_hik(self) -> None:\n    hss = self.any_hss(remote_proxy=remote_proxies.hik)\n    driver = driver_factory.get_driver(hss)\n    assert_that(driver, instance_of(HssDriver))\n", "output": "2"}