val_code.jsonl

{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_save_initial__message(self) -> None:\n    \"\"\"\n    Given any request in initial state\n    When I save 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(client=self.client, site_slug=request.site.slug, pk=request.pk).form.save()\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": "代码：\n@vcr.use_cassette()\ndef test_update_scenarios__incorrect_hss_pk(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario with new data\n    When : I put this dict to an url containing an hss_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, hss_pk=1234)\n    assert_that(last_response.status_code, is_(404), last_response.content)\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_scheduler__with_same_credits(self) -> None:\n    \"\"\"\n    Given : A credits pack with a specific amount of credits\n    When : I create a scheduler with the same amount of credits than the credits pack\n    Then : Validation error is raised\n    \"\"\"\n    credits_pack = self.any_credits_pack()\n    with self.assertRaises(ValidationError) as e:\n        self.any_credits_pack_scheduler(credits_pack=credits_pack, schedule_credits=credits_pack.credits)\n\n    assert_that(e.exception.messages[0], is_(\"A scheduler needs to have a different bonus than the base credits.\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@override_settings(USE_PROMOCODE_PREFIX_NF0=True)\ndef test_find_promocode_with_promocode_prefix_active(self) -> None:\n    \"\"\"\n    Given a\n        cart\n        promocode with an NF0 code\n        settings USE_PROMOCODE_PREFIX_NF0 active\n    When I search for a promocode with only the number after NF0 from the code\n    Then I find it and I get an http response with a status code 200\n    \"\"\"\n    self.client = AuthenticatedClient()\n    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    # Provide only what is after NF0\n    self.when_i_search_promocode(cart=cart, code=\"99225\")\n\n    assert_that(self.last_response, http(200))\n", "output": "3"}
{"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_(False))\n    assert_that(hss_rating_config.rating_config, is_(none()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_can_cancel__my_request__with_notice_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.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            my_request = self.any_quoted_request(creator=u1, state=request_states.planned)\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=my_request),\n                is_(can_cancel_from_planned_expected_result[role][\"my_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][\"my_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=my_request),\n                expected_matcher,\n            )\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_person_image__not_found(self) -> None:\n    bec_driver = BecDriverV4()\n    contract = self.any_remote_contract(contract_number=default_climax_account.contract_numbers[0])\n    person = self.any_remote_person(contract_number=contract.contract_number)\n    with self.assertRaises(NotFound):\n        bec_driver.get_person_image(\n            contract_number=contract.contract_number,\n            image_path=f\"/bec/private-media/person/{person.uuid}/74d8346e-bee4-4c9b-b589-5e02be9fdbef.png\",\n        )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_form__duplicate(self) -> None:\n    \"\"\"\n    Given :\n        a category\n        a dict with a representation of a category with same title\n    when I save the form\n    Then I have an error\n    \"\"\"\n    category_1 = self.any_category()\n    data = {\n        \"title\": category_1.title,\n        \"slug_icon\": subjects_slug.card,\n        \"order\": 1,\n    }\n    form = CategoryForm(data)\n    form_valid = form.is_valid()\n\n    assert_that(form_valid, is_(False))\n    assert_that(str(form.errors), contains_string(\"Une catégorie avec ce titre existe déjà:\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get__with_request_filter(self) -> None:\n    filters = self.any_request_filter(creator=self.client.user, site=self.client.current_site)\n    filters.creation_time_range = (datetime.date.today(), datetime.date.today() + datetime.timedelta(days=1))\n    filters.save()\n    page = RequestListPage.get(client=self.client, site_slug=self.client.current_site.slug)\n    from_date, to_date = page.request_filter.creation_time_range\n    assert_that(from_date, is_(datetime.date.today().strftime(\"%d/%m/%Y\")))\n    assert_that(to_date, is_(datetime.date.today().strftime(\"%d/%m/%Y\")))\n", "output": "1"}
{"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 codes\n    Then:\n        - I get a list of dataclass Code\n        - I create the database Code objects\n    \"\"\"\n    Code.objects.all().delete()\n\n    hss = self.any_hss(remote_proxy=remote_proxies.climax_kiz)\n    driver = driver_factory.get_driver(hss)\n    codes = driver.codes.list()\n    assert_that(codes, only_contains(instance_of(GenericCode)))\n    assert_that(len(codes), is_(Code.objects.count()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_perm__dashboard__disabled(self) -> None:\n    site = self.any_site()\n    site.dashboard_is_enable = False\n    site.save()\n    for role in permission_roles.all:\n        user = self.any_user(roles=[role], sites=[site.uuid])\n        with self.subTest(role=role):\n            has_perm = user.has_perm(site_permissions.can_view_dashboard, obj=site)\n            assert_that(has_perm, is_(False))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_client_raises_message_lost_on_climax_message_lost_payload(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(\n            self._mock_endpoint,\n            status_code=200,\n            json={\"message\": \"Message non transmis a la centrale, veuillez réessayer plus tard.\"},\n        )\n        assert_that(calling(client.request).with_args(self._mock_endpoint), raises(MessageLost))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_processing_catalogue_file_none(self) -> None:\n    wp_importer = self.any_washing_program_importer()\n    wp_importer.state = states.processing\n    wp_importer.catalogue_file.delete()\n    with self.assertRaises(ValidationError) as e:\n        wp_importer.clean()\n    assert_that(e.exception.error_dict, has_entry(\"catalogue_file\", is_(not_none())))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_create_form_on_valid(self) -> None:\n    data = {\n        \"status\": \"on\",\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==1\")  # 'on'\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_loader_station__delete(self) -> None:\n    \"\"\"\n    Given a station loader and an autowash json from autowash-reference\n    When I load an autowash message without any value\n    Then station.enabled = False\n    \"\"\"\n    loader = AutowashLoader()\n    message = load(\"autowash.json\")\n    key = message[\"uri\"].split(\"/\")[-1]\n\n    loader.on_message(\"resource.tw.autowash\", message, key)\n\n    assert_that(\n        Station.objects.filter(source_id=message[\"uri\"]).get(),\n        has_property(\"enabled\", is_(True)),\n    )\n\n    loader.on_message(\"resource.tw.autowash\", None, key)\n\n    assert_that(\n        Station.objects.filter(source_id=message[\"uri\"]).get(),\n        has_property(\"enabled\", is_(False)),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_click_request_notifications_preferences(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        .notifications_preferences.click(next_page_class=RequestNotificationsPage)\n    )\n    assert_that(page, is_(RequestNotificationsPage))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_setup_periodic_tasks(self) -> None:\n    celery = Celery()\n    setup_periodic_tasks(sender=celery)\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_ping(self) -> None:\n    self.when_i_ping()\n\n    assert_that(self.last_response.status_code, is_(status.HTTP_200_OK))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_generate_transportation_warrant_attachment(self) -> None:\n    request = self.any_request(state=request_states.tms_transmission)\n    request.generate_transportation_warrant_attachment()\n    assert_that(request.transportation_warrant_attachment, is_not(none()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_serializer__null_values(self) -> None:\n    climax_powerswitches_json = load(\"climax_panel_device_list_pss_get.json\")\n    climax_powerswitches_json[\"devices\"][\"pss\"][0][\"id2\"] = None\n    hss = self.any_hss()\n    serializer = ListResponseSerializer(data=climax_powerswitches_json)\n    serializer.is_valid(raise_exception=True)\n    powerswitches = serializer.save(hss=hss)\n    assert_that(powerswitches, not_none())\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_list_scenario_devices(self) -> None:\n    \"\"\"\n    Given : A panel with devices\n    When : I list scenario devices, for this panel\n    Then : I get a 200 HTTP response\n    \"\"\"\n    last_response = self.when_i_list_scenario_devices()\n    assert_that(last_response.status_code, is_(200), last_response.content)\n    assert_that(last_response.json(), has_length(greater_than(0)), last_response.content)\n    assert_that(\n        last_response.json()[0],\n        has_entries({\"pk\": instance_of(str), \"model\": is_(\"hss.scenario.device\"), \"fields\": instance_of(dict)}),\n    )\n    assert_that(\n        last_response.json()[0][\"fields\"],\n        has_entries({\"name\": instance_of(str), \"id\": instance_of(str), \"device_type\": instance_of(str)}),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_access_token_with_post_request_body(self) -> None:\n    self._request_token(METHOD_POST_REQUEST_BODY)\n    self._authorize_and_access_token_using_form(METHOD_POST_REQUEST_BODY)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_create_scenarios__incorrect_condition_data(self) -> None:\n    \"\"\"\n    Given : A dict representing a scenario, with an action with incorrect data\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    data[\"condition\"][\"fields\"].pop(\"weekdays\")\n    last_response = self.when_i_post_scenario(data)\n    assert_that(last_response.status_code, is_(400), last_response.content)\n    assert_that(last_response.json(), is_(not_none()))\n    assert_that(last_response.json(), has_entry(\"condition\", not_none()))\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get__no_billing_information(self) -> None:\n    \"\"\"\n    Given a user without billing information\n    When i get billing information for this user\n    Then I get\n        - HTTP 200\n        - valid data with empty fields\n    \"\"\"\n    self.client = AuthenticatedClient()\n    user = self.client.user\n    user.billing_information = None\n    user.save()\n\n    self.when_i_get_billing_information()\n\n    assert user.billing_information\n    assert_that(self.last_response.status_code, equal_to(200))\n    assert_that(\n        self.last_response.json(),\n        has_entries(\n            {\n                \"pk\": str(user.billing_information.pk),\n                \"model\": \"accounts.billing_information\",\n                \"fields\": has_entries(\n                    {\n                        \"name\": \"\",\n                        \"street_address\": \"\",\n                        \"postal_code\": \"\",\n                        \"locality\": \"\",\n                        \"vat_number\": \"\",\n                        \"additional_information\": \"\",\n                    }\n                ),\n            }\n        ),\n    )\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_requester_job_position_is_optional(self) -> None:\n    \"\"\"\n    Given a tms_transmission request without requester job position\n    When I save\n    Then it doesn't crash\n    \"\"\"\n    request = self.any_framed_request(\n        state=request_states.tms_transmission, with_packaging_units=False, with_carriages=True\n    )\n    request.requester_job_position = \"\"\n    request.save()\n    assert_that(request.requester_job_position, is_(\"\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_non_twip_user_cant_set_booking_vehicle(self) -> None:\n    self.client = AuthenticatedClient(mangopay_card=mangopay_cards.normal)\n    station = self.any_twip_station()\n    booking = self.sync_create_booking(station)\n    url = reverse(\"api:v40:twip:booking-detail\", kwargs={\"pk\": booking.pk})\n    response = self.client.put(\n        url, data={\"vehicle_registration\": \"FR-123-AD\", \"vehicle_type\": vehicle_types.sedan}\n    )\n    assert_that(response.status_code, is_(400))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_get_private_station__no_corporation(self) -> None:\n    \"\"\"\n    Given\n        - any user wihtout corporation\n        - a station\n    When this user try to get station pivate\n    Then i get an HTTP 404\n    \"\"\"\n    self.client = AuthenticatedClient()\n    self.any_station(source=source_profile.twip_source)\n    self.when_i_get_private_station()\n\n    assert_that(self.last_response, http(404))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\n@vcr.use_cassette()\ndef test_update_status(self) -> None:\n    \"\"\"\n    Given:\n        - a Hss with Honeywell panel\n        - a HssDriver\n        - a honeywell powerswitch with a status set to off\n    When:\n        - I update powerswitch's status\n    Then:\n        - I get an updated powerswitch\n    \"\"\"\n    for status in {powerswitch_status.on, powerswitch_status.off}:\n        with self.subTest(status=status):\n            hss = self.any_configured_hss(account=default_honeywell_account)\n            driver = driver_factory.get_driver(hss=hss)\n            honeywell_powerswitch = self.any_honeywell_powerswitch(hss=hss)\n            driver.power_switches.update_status(\n                device_id=str(honeywell_powerswitch.id), status=powerswitch_status.off\n            )\n            updated_honeywell_powerswitch = driver.power_switches.update_status(\n                device_id=str(honeywell_powerswitch.id), status=status\n            )\n            assert_that(updated_honeywell_powerswitch, not_none())\n            assert_that(updated_honeywell_powerswitch.status, is_(status))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_repository(self) -> None:\n    \"\"\"\n    Given 1 zone_context and 1 credits pack associated with this zone_context\n    When I call the repository\n    Then I get 1 credits pack\n    \"\"\"\n    zone_context = self.any_zone_context()\n    self.any_credits_pack(zone_context=zone_context)\n    filtered = CreditsPackRepository().get_all(zone_context)\n    assert_that(len(filtered), is_(1))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_loader(self) -> None:\n    \"\"\"\n    Given a team json and a loader\n    When load json\n    Then team is valid\n    \"\"\"\n    team_msg = load(\"team.json\")\n    team = TeamLoader().on_message(\"iwp.resource.team\", team_msg)\n    assert team\n    assert_that(team.uri.value, is_(team_msg[\"uri\"]))\n    assert_that(team.users.all(), has_length(2))\n    assert_that([user.uri.value for user in team.users.all()], contains_inanyorder(*team_msg[\"data\"][\"users\"]))\n    assert team.site\n    assert_that(team.site.uri, team_msg[\"data\"][\"site\"])\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_list__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    self.client.user.save()\n    self.when_i_list_order()\n\n    assert_that(self.last_response.status_code, is_(403))\n    assert_that(\n        self.last_response.json(),\n        has_entry(\"detail\", starts_with(\"Par mesure de sécurité, votre compte a été suspendu.\")),\n    )\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_buy_with_force_3DS_async(self, *mocks) -> None:\n    buyer_account = self.any_mangopay_account_with_card_3D_secure()\n    recipient_user = self.given_mangopay_recipient_user()\n    amount = self.given_amount_greater_under_3DS_limit()\n    secure_mode = secure_modes.FORCE\n\n    def on_init(sender, transaction, **kwargs):\n        self.assertEqual(transaction.state, transaction_states.initial)\n        self.assertEqual(transaction.secure_mode, secure_mode)\n        self.on_init_called = True\n\n    transaction_initiated.connect(on_init)\n\n    def on_waiting_3DS(sender, transaction, **kwargs):\n        self.when_i_3d_validate_payment(transaction)\n\n        self.assertTrue(transaction.id)\n        self.then_transactions_count_is(1, transaction.transaction_type)\n\n        transaction.wait_for_completion()\n        self.on_waiting_3DS_called = True\n\n    transaction_waiting_3DS.connect(on_waiting_3DS)\n\n    def on_success(sender, transaction, **kwargs):\n        self.then_transaction_is_success(\n            transaction.id, amount, secure_mode=secure_mode, card_type=buyer_account.default_card().card_type\n        )\n        self.on_success_called = True\n\n    transaction_succeed.connect(on_success)\n\n    # 1: Create transaction\n    self.when_i_create_payin(\n        buyer_account,\n        recipient_user,\n        amount,\n        secure_mode=secure_mode,\n        run_async=True,\n        secure_mode_version=secure_mode_versions.secure_mode_3ds1,\n    )\n\n    self.assertTrue(self.on_init_called)\n    self.assertTrue(self.on_waiting_3DS_called)\n    self.assertTrue(self.on_success_called)\n    transaction_initiated.disconnect(on_init)\n    transaction_waiting_3DS.disconnect(on_waiting_3DS)\n    transaction_succeed.disconnect(on_success)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_request_formatter__merchandises_carriages(self) -> None:\n    \"\"\"\n    Given any request with no packaging units\n    When I use RequestFormatter with 'merchandises' field to export\n    Then it return a dict that contain \"\"\n    \"\"\"\n    request = self.any_request(\n        state=request_states.draft,\n        transport_service=transport_services.packaging_units,\n        with_packaging_units=False,\n        with_carriages=True,\n    )\n    request_csv = RequestFormatter().to_csv(request, fields=[\"merchandises\"])\n    assert_that(request_csv[0], is_(\"\"))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_update_card_registration(self, *mocks) -> None:\n    mangopay_user = self.any_mangopay_user()\n    account = mangopay.get_account(mangopay_user)\n    account.create(person_type=USER_TYPE_CHOICES.natural)\n    account.default_card_registration().create()\n    registration_data = self.when_i_register_card_data(account.default_card_registration())\n    account.default_card_registration().update(registration_data)\n    self.then_card_registration_is_valid(account, mangopay_user)\n    self.assertTrue(account.default_card_registration().card_id)\n    self.assertTrue(mangopay_user.card.mangopay_card_id)\n    self.assertEqual(account.default_card_registration().card_id, mangopay_user.card.mangopay_card_id)\n    self.assertFalse(mangopay_user.card.has_valid_mangopay_card)\n", "output": "1"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_issue_is_fixed(self) -> None:\n    self.client = AuthenticatedClient()\n    cart = self.any_cart(user=self.client.user, state=cart_states.active, api_version=API_VERSION)\n    cart.start_checkout(payment_method=\"mangopay\")\n    self.when_i_delete_cart_item(cart_id=cart.id, cart_item_id=cart.cartitem_set.first().id)\n    assert_that(self.last_response, http(400))\n    assert_that(self.last_response.json(), has_entry(\"__all__\", not_none()))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_invoice_reference_required__submit(self) -> None:\n    \"\"\"\n    Given :\n        - a invoice_reference parameter with required = True\n        - a request in initial state\n    When i validate form (with action = submit) without invoice_reference\n    Then I get an error\n    \"\"\"\n    conf = self.any_global_configuration_from_migration(name=\"request.invoice_reference\")\n    conf.required = True\n    conf.full_clean()\n    conf.save()\n    request = self.any_request(state=request_states.initial, ready_to_submit=False)\n    data = self.any_reference_form_data(request=request)\n    data[\"references-invoice_reference\"] = \"\"\n    form = make_references_form(instance=request, read_only=False, action=form_actions.submit)(\n        instance=request, data=data\n    )\n    assert_that(form.fields[\"invoice_reference\"].required, is_(True))\n    assert_that(form.is_valid(), is_(False))\n    assert_that(form.errors, has_entry(\"invoice_reference\", not_(empty())))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_generate_transportation_warrant(self) -> None:\n    \"\"\"\n    Given a request in waiting state with a transportation warrant\n    When I call task generate_transportation_warrant\n    Then a new transportation warrant is generated\n    \"\"\"\n    request = self.any_request(state=request_states.waiting)\n    request.generate_transportation_warrant_attachment()\n    old_transportation_warrant = request.transportation_warrant_attachment\n    assert_that(Attachment.objects.count(), is_(1))\n    tasks.generate_transportation_warrant(request_pk=request.uuid)\n    request.refresh_from_db()\n    assert_that(Attachment.objects.count(), is_(1))\n    assert_that(request.transportation_warrant_attachment, is_(not_(old_transportation_warrant)))\n", "output": "2"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_issue_is_fixed(self) -> None:\n    \"\"\"\n    load fixture pack corresponding to our test data\n    \"\"\"\n    load_fixture_pack(\"iwp_238\", root=Path(__file__).parent)\n    request = Request.objects.get(uuid=\"6016c7c3-ae03-4a4b-8878-6b82ad72edb5\")\n    assert_that(request.state, is_(request_states.completed))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_credits_pack__only_bonus__no_discount__prices(self) -> None:\n    \"\"\"\n    Given any credits pack scheduler in progress without promocode\n    When I buy credit pack\n    Then orderitem has:\n        - corrected_price_before_discount is equal to credits_pack_price\n        - corrected_price_before_discount is not equal to price_before_discount\n        - price_after_discount is equal to corrected_price_after_discount\n    \"\"\"\n\n    credits_pack = self.any_credits_pack(credits=100)\n    deal = self.any_deal(\n        price_after_discount=decimal.Decimal(\"10\"),\n        price_before_discount=decimal.Decimal(\"15\"),\n        profile=deal_profiles.credits_pack,\n        credits_pack=credits_pack,\n    )\n    user = self.any_user(mangopay_card=mangopay_cards.normal, with_mp_user=True)\n\n    cart = self.any_cart(user=user, state=cart_states.empty)\n    cart.add_item(deal=deal)\n\n    order = self.any_order(user=user, payment_method=payment_methods.mangopay, cart=cart)\n    assert_that(order.promocode_type, is_(None))\n    assert_that(order.offer_type, is_(None))\n\n    orderitem = order.orderitem_set.get()\n    assert_that(orderitem.corrected_price_before_discount, is_(orderitem.credits_pack_price))\n    assert_that(orderitem.corrected_price_before_discount, not_(orderitem.price_before_discount))\n    assert_that(orderitem.price_after_discount, is_(orderitem.corrected_price_after_discount))\n", "output": "3"}
{"instruction": "你是代码测试质量评估器。请根据给定的单元测试代码（以及可选的度量指标）判断质量类别，只输出一个数字标签：1、2 或 3。不要输出任何解释或多余文本。", "input": "代码：\ndef test_read_contract_with_last_mail_sent(self) -> None:\n    \"\"\"\n    Given:\n        - A contract\n    When:\n        - I trigger mail\n    Then:\n        - I get a 200 with a last_mail_sent set in the contract\n    \"\"\"\n    hss = self.any_hss()\n    BECContractMixin().any_remote_contract(contract_number=hss.site.contract.contract_number)\n    bec_driver = BecDriverV4()\n    trigger_mail_data = {\n        \"mail_type\": \"instructions\",\n        \"agent_username\": \"lguerin\",\n    }\n    bec_driver.contracts_trigger_mail(contract_number=hss.site.contract.contract_number, data=trigger_mail_data)\n    self.when_i_get_contract(contract_number=hss.site.contract.contract_number)\n    assert_that(self.last_response.status_code, is_(status.HTTP_200_OK))\n    assert_that(self.last_response.json(), contract_matcher(contract_number=hss.site.contract.contract_number))\n    assert_that(self.last_response.json()[\"fields\"][\"last_mail_sent\"], not_none())\n", "output": "3"}