Python UserPartition.from_json方法代码示例

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
    def test_from_json_broken(self):
        # Missing field
        jsonified = {
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "version": UserPartition.VERSION,
            "scheme": self.TEST_SCHEME_NAME,
        }
        with self.assertRaisesRegexp(TypeError, "missing value key 'id'"):
            UserPartition.from_json(jsonified)

        # Missing scheme
        jsonified = {
            'id': self.TEST_ID,
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "version": UserPartition.VERSION,
        }
        with self.assertRaisesRegexp(TypeError, "missing value key 'scheme'"):
            UserPartition.from_json(jsonified)

        # Invalid scheme
        jsonified = {
            'id': self.TEST_ID,
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "version": UserPartition.VERSION,
            "scheme": "no_such_scheme",
        }
        with self.assertRaisesRegexp(UserPartitionError, "Unrecognized scheme"):
            UserPartition.from_json(jsonified)

        # Wrong version (it's over 9000!)
        # Wrong version (it's over 9000!)
        jsonified = {
            'id': self.TEST_ID,
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "version": 9001,
            "scheme": self.TEST_SCHEME_NAME,
        }
        with self.assertRaisesRegexp(TypeError, "has unexpected version"):
            UserPartition.from_json(jsonified)

        # Has extra key - should not be a problem
        jsonified = {
            'id': self.TEST_ID,
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "version": UserPartition.VERSION,
            "scheme": "mock",
            "programmer": "Cale",
        }
        user_partition = UserPartition.from_json(jsonified)
        self.assertNotIn("programmer", user_partition.to_json())

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def get_user_partition(self):
     """
     Get user partition for saving in course.
     """
     try:
         return UserPartition.from_json(self.configuration)
     except ReadOnlyUserPartitionError:
         raise GroupConfigurationsValidationError(_("unable to load this type of group configuration"))

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
    def test_version_upgrade_2_to_3(self):
        # Test that version 3 user partition raises error if 'scheme' field is
        # not provided (same behavior as version 2)
        jsonified = {
            'id': self.TEST_ID,
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "parameters": self.TEST_PARAMETERS,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "version": 2,
        }
        with self.assertRaisesRegexp(TypeError, "missing value key 'scheme'"):
            UserPartition.from_json(jsonified)

        # Test that version 3 partitions have a scheme specified
        # and a field 'parameters' (optional while setting user partition but
        # always present in response)
        jsonified = {
            "id": self.TEST_ID,
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "version": 2,
            "scheme": self.TEST_SCHEME_NAME,
        }
        user_partition = UserPartition.from_json(jsonified)
        self.assertEqual(user_partition.scheme.name, self.TEST_SCHEME_NAME)
        self.assertEqual(user_partition.parameters, {})
        self.assertTrue(user_partition.active)

        # now test that parameters dict is present in response with same value
        # as provided
        jsonified = {
            "id": self.TEST_ID,
            "name": self.TEST_NAME,
            "description": self.TEST_DESCRIPTION,
            "groups": [group.to_json() for group in self.TEST_GROUPS],
            "parameters": self.TEST_PARAMETERS,
            "version": 3,
            "scheme": self.TEST_SCHEME_NAME,
        }
        user_partition = UserPartition.from_json(jsonified)
        self.assertEqual(user_partition.parameters, self.TEST_PARAMETERS)
        self.assertTrue(user_partition.active)

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def test_version_upgrade(self):
     # Version 1 partitions did not have a scheme specified
     jsonified = {
         "id": self.TEST_ID,
         "name": self.TEST_NAME,
         "description": self.TEST_DESCRIPTION,
         "groups": [group.to_json() for group in self.TEST_GROUPS],
         "version": 1,
     }
     user_partition = UserPartition.from_json(jsonified)
     self.assertEqual(user_partition.scheme.name, "random")

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
    def test_from_json_broken(self):
        groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
        upid = 1
        upname = "Test Partition"
        updesc = "For Testing Purposes"

        # Missing field
        jsonified = {
            "name": upname,
            "description": updesc,
            "groups": [group.to_json() for group in groups],
            "version": UserPartition.VERSION
        }
        with self.assertRaisesRegexp(TypeError, "missing value key 'id'"):
            user_partition = UserPartition.from_json(jsonified)

        # Wrong version (it's over 9000!)
        jsonified = {
            'id': upid,
            "name": upname,
            "description": updesc,
            "groups": [group.to_json() for group in groups],
            "version": 9001
        }
        with self.assertRaisesRegexp(TypeError, "has unexpected version"):
            user_partition = UserPartition.from_json(jsonified)

        # Has extra key - should not be a problem
        jsonified = {
            'id': upid,
            "name": upname,
            "description": updesc,
            "groups": [group.to_json() for group in groups],
            "version": UserPartition.VERSION,
            "programmer": "Cale"
        }
        user_partition = UserPartition.from_json(jsonified)
        self.assertNotIn("programmer", user_partition.to_json())

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def test_version_upgrade(self):
     # Test that version 1 partitions did not have a scheme specified
     # and have empty parameters
     jsonified = {
         "id": self.TEST_ID,
         "name": self.TEST_NAME,
         "description": self.TEST_DESCRIPTION,
         "groups": [group.to_json() for group in self.TEST_GROUPS],
         "version": 1,
     }
     user_partition = UserPartition.from_json(jsonified)
     self.assertEqual(user_partition.scheme.name, "random")  # pylint: disable=no-member
     self.assertEqual(user_partition.parameters, {})
     self.assertTrue(user_partition.active)

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
def group_configurations_list_handler(request, course_key_string):
    """
    A RESTful handler for Group Configurations

    GET
        html: return Group Configurations list page (Backbone application)
    POST
        json: create new group configuration
    """
    course_key = CourseKey.from_string(course_key_string)
    course = _get_course_module(course_key, request.user)
    store = modulestore()

    if 'text/html' in request.META.get('HTTP_ACCEPT', 'text/html'):
        group_configuration_url = reverse_course_url('group_configurations_list_handler', course_key)
        split_test_enabled = SPLIT_TEST_COMPONENT_TYPE in course.advanced_modules

        return render_to_response('group_configurations.html', {
            'context_course': course,
            'group_configuration_url': group_configuration_url,
            'configurations': [u.to_json() for u in course.user_partitions] if split_test_enabled else None,
        })
    elif "application/json" in request.META.get('HTTP_ACCEPT') and request.method == 'POST':
        # create a new group configuration for the course
        try:
            configuration = GroupConfiguration.parse(request.body)
            GroupConfiguration.validate(configuration)
        except GroupConfigurationsValidationError as err:
            return JsonResponse({"error": err.message}, status=400)

        if not configuration.get("id"):
            configuration["id"] = random.randint(100, 10**12)

        # Assign ids to every group in configuration.
        for index, group in enumerate(configuration.get('groups', [])):
            group["id"] = index

        course.user_partitions.append(UserPartition.from_json(configuration))
        store.update_item(course, request.user.id)
        response = JsonResponse(configuration, status=201)

        response["Location"] = reverse_course_url(
            'group_configurations_detail_handler',
            course.id,
            kwargs={'group_configuration_id': configuration["id"]}
        )
        return response
    else:
        return HttpResponse(status=406)

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def test_forward_compatibility(self):
     # If the user partition version is updated in a release,
     # then the release is rolled back, courses might contain
     # version numbers greater than the currently deployed
     # version number.
     newer_version_json = {
         "id": self.TEST_ID,
         "name": self.TEST_NAME,
         "description": self.TEST_DESCRIPTION,
         "groups": [group.to_json() for group in self.TEST_GROUPS],
         "version": UserPartition.VERSION + 1,
         "scheme": "mock",
         "additional_new_field": "foo",
     }
     partition = UserPartition.from_json(newer_version_json)
     self.assertEqual(partition.id, self.TEST_ID)
     self.assertEqual(partition.name, self.TEST_NAME)

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def test_from_json(self):
     jsonified = {
         "id": self.TEST_ID,
         "name": self.TEST_NAME,
         "description": self.TEST_DESCRIPTION,
         "groups": [group.to_json() for group in self.TEST_GROUPS],
         "version": UserPartition.VERSION,
         "scheme": "mock",
     }
     user_partition = UserPartition.from_json(jsonified)
     self.assertEqual(user_partition.id, self.TEST_ID)
     self.assertEqual(user_partition.name, self.TEST_NAME)
     self.assertEqual(user_partition.description, self.TEST_DESCRIPTION)
     for act_group in user_partition.groups:
         self.assertIn(act_group.id, [0, 1])
         exp_group = self.TEST_GROUPS[act_group.id]
         self.assertEqual(exp_group.id, act_group.id)
         self.assertEqual(exp_group.name, act_group.name)

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
    def test_from_json(self):
        groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
        upid = 1
        upname = "Test Partition"
        updesc = "For Testing Purposes"

        jsonified = {
            "id": upid,
            "name": upname,
            "description": updesc,
            "groups": [group.to_json() for group in groups],
            "version": UserPartition.VERSION
        }
        user_partition = UserPartition.from_json(jsonified)
        self.assertEqual(user_partition.id, upid)
        self.assertEqual(user_partition.name, upname)
        self.assertEqual(user_partition.description, updesc)
        for act_group in user_partition.groups:
            self.assertIn(act_group.id, [0, 1])
            exp_group = groups[act_group.id]
            self.assertEqual(exp_group.id, act_group.id)
            self.assertEqual(exp_group.name, act_group.name)

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def from_json(self, values):
     return [UserPartition.from_json(v) for v in values]

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def test_from_json_not_supported(self):
     user_partition_json = create_enrollment_track_partition(self.course).to_json()
     with self.assertRaises(ReadOnlyUserPartitionError):
         UserPartition.from_json(user_partition_json)

# 需要导入模块: from xmodule.partitions.partitions import UserPartition [as 别名]
# 或者: from xmodule.partitions.partitions.UserPartition import from_json [as 别名]
 def get_user_partition(self):
     """
     Get user partition for saving in course.
     """
     return UserPartition.from_json(self.configuration)