Repository: netbox-community/netbox

Issue:
Exception when creating bulk devices using the API with a custom field.
### Environment
* Python version:  3.7.6
* NetBox version:  2.7.8

### Steps to Reproduce
1. Install NetBox 2.7.8. I used [netbox-docker](https://github.com/netbox-community/netbox-docker).
2. Create an optional custom field on device objects.
3. Add a device role, device type, and site.
4. Attempt to create multiple devices in one API call, using either pynetbox or the interactive API docs, providing only the minimum necessary fields.

### Expected Behavior
All devices to be created successfully.

### Observed Behavior
```
...
File "/opt/netbox/netbox/extras/api/customfields.py" in __init__
  132.                 self.initial_data['custom_fields'] = {}
Exception Type: TypeError at /api/dcim/devices/
Exception Value: list indices must be integers or slices, not str
```


Discussion:
> Attempt to create multiple devices in one API call

Please provide the exact API call needed to recreate the issue (using `curl`).
```
curl -X POST -H "Authorization: Token ${TOKEN}" -H "Content-Type: application/json" -d '[{"device_type": 1, "device_role": 1, "site": 1}]' http://0.0.0.0:32768/api/dcim/devices/
```
```
curl -X POST "https://master.netbox.dansheps.com/api/dcim/devices/" -H "accept: application/json" -H "Content-Type: application/json" -d "[{ \"device_type\": 1, \"device_role\": 1, \"site\": 2},{ \"device_type\": 1, \"device_role\": 1, \"site\": 2}]"

[
  {
    "id": 5,
...
  },
  {
    "id": 6,
...
  }
]
```

Could you try against master.netbox.dansheps.com please?  I am not seeing any issues
Hi @DanSheps, I think you forgot to create a custom field. Once I created a custom field on your instance, I was able to reproduce the error against `master.netbox.dansheps.com`.

```
mana:~ ebusto$ curl -X POST "https://master.netbox.dansheps.com/api/dcim/devices/" -H "accept: application/json" -H "Content-Type: application/json" -d "[{ \"device_type\": 1, \"device_role\": 1, \"site\": 2},{ \"device_type\": 1, \"device_role\": 1, \"site\": 2}]" -H "Authorization: Token <token>"

<!DOCTYPE html>
<html lang="en">

<head>
    <title>Server Error</title>
    <link rel="stylesheet" href="/static/bootstrap-3.4.1-dist/css/bootstrap.min.css">
    <link rel="stylesheet" href="/static/font-awesome-4.7.0/css/font-awesome.min.css">
    <meta charset="UTF-8">
</head>
...
```
Yeah, that was my bad, I thought there were some custom fields created already.
I can reproduce this issue with custom fields.
This is caused at the following line because `self.initial_data` is expected as dict not list.
https://github.com/netbox-community/netbox/blob/7b6bd75c22196a28b6aa241b4146c6000ff3805c/netbox/extras/api/customfields.py#L130-L132

It is trying to set `custom_fields` not to each device object but to list of them.

Does NetBox support bulk import through `/api/dcim/devices`?
If so, we need to modify `CustomFieldModelSerializer` to support this. Or may be much better way.
This code was written a long time ago, before we implemented the ability to create multiple items in bulk via the REST API. It likely needs a substantial amount of refactoring. I'll dig into this some more.

Resolving patch:
diff --git a/netbox/extras/api/customfields.py b/netbox/extras/api/customfields.py
--- a/netbox/extras/api/customfields.py
+++ b/netbox/extras/api/customfields.py
@@ -1,9 +1,11 @@
 from datetime import datetime
 
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ObjectDoesNotExist
 from django.db import transaction
 from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
+from rest_framework.fields import CreateOnlyDefault
 
 from extras.choices import *
 from extras.models import CustomField, CustomFieldChoice, CustomFieldValue
@@ -14,6 +16,43 @@
 # Custom fields
 #
 
+class CustomFieldDefaultValues:
+    """
+    Return a dictionary of all CustomFields assigned to the parent model and their default values.
+    """
+    def __call__(self):
+
+        # Retrieve the CustomFields for the parent model
+        content_type = ContentType.objects.get_for_model(self.model)
+        fields = CustomField.objects.filter(obj_type=content_type)
+
+        # Populate the default value for each CustomField
+        value = {}
+        for field in fields:
+            if field.default:
+                if field.type == CustomFieldTypeChoices.TYPE_INTEGER:
+                    field_value = int(field.default)
+                elif field.type == CustomFieldTypeChoices.TYPE_BOOLEAN:
+                    # TODO: Fix default value assignment for boolean custom fields
+                    field_value = False if field.default.lower() == 'false' else bool(field.default)
+                elif field.type == CustomFieldTypeChoices.TYPE_SELECT:
+                    try:
+                        field_value = field.choices.get(value=field.default).pk
+                    except ObjectDoesNotExist:
+                        # Invalid default value
+                        field_value = None
+                else:
+                    field_value = field.default
+                value[field.name] = field_value
+            else:
+                value[field.name] = None
+
+        return value
+
+    def set_context(self, serializer_field):
+        self.model = serializer_field.parent.Meta.model
+
+
 class CustomFieldsSerializer(serializers.BaseSerializer):
 
     def to_representation(self, obj):
@@ -94,53 +133,35 @@ class CustomFieldModelSerializer(ValidatedModelSerializer):
     """
     Extends ModelSerializer to render any CustomFields and their values associated with an object.
     """
-    custom_fields = CustomFieldsSerializer(required=False)
+    custom_fields = CustomFieldsSerializer(
+        required=False,
+        default=CreateOnlyDefault(CustomFieldDefaultValues())
+    )
 
     def __init__(self, *args, **kwargs):
-
-        def _populate_custom_fields(instance, fields):
-            instance.custom_fields = {}
-            for field in fields:
-                value = instance.cf.get(field.name)
-                if field.type == CustomFieldTypeChoices.TYPE_SELECT and value is not None:
-                    instance.custom_fields[field.name] = CustomFieldChoiceSerializer(value).data
-                else:
-                    instance.custom_fields[field.name] = value
-
         super().__init__(*args, **kwargs)
 
-        # Retrieve the set of CustomFields which apply to this type of object
-        content_type = ContentType.objects.get_for_model(self.Meta.model)
-        fields = CustomField.objects.filter(obj_type=content_type)
-
         if self.instance is not None:
 
+            # Retrieve the set of CustomFields which apply to this type of object
+            content_type = ContentType.objects.get_for_model(self.Meta.model)
+            fields = CustomField.objects.filter(obj_type=content_type)
+
             # Populate CustomFieldValues for each instance from database
             try:
                 for obj in self.instance:
-                    _populate_custom_fields(obj, fields)
+                    self._populate_custom_fields(obj, fields)
             except TypeError:
-                _populate_custom_fields(self.instance, fields)
-
-        else:
-
-            if not hasattr(self, 'initial_data'):
-                self.initial_data = {}
-
-            # Populate default values
-            if fields and 'custom_fields' not in self.initial_data:
-                self.initial_data['custom_fields'] = {}
-
-            # Populate initial data using custom field default values
-            for field in fields:
-                if field.name not in self.initial_data['custom_fields'] and field.default:
-                    if field.type == CustomFieldTypeChoices.TYPE_SELECT:
-                        field_value = field.choices.get(value=field.default).pk
-                    elif field.type == CustomFieldTypeChoices.TYPE_BOOLEAN:
-                        field_value = bool(field.default)
-                    else:
-                        field_value = field.default
-                    self.initial_data['custom_fields'][field.name] = field_value
+                self._populate_custom_fields(self.instance, fields)
+
+    def _populate_custom_fields(self, instance, custom_fields):
+        instance.custom_fields = {}
+        for field in custom_fields:
+            value = instance.cf.get(field.name)
+            if field.type == CustomFieldTypeChoices.TYPE_SELECT and value is not None:
+                instance.custom_fields[field.name] = CustomFieldChoiceSerializer(value).data
+            else:
+                instance.custom_fields[field.name] = value
 
     def _save_custom_fields(self, instance, custom_fields):
         content_type = ContentType.objects.get_for_model(self.Meta.model)


Test patch:
diff --git a/netbox/extras/tests/test_customfields.py b/netbox/extras/tests/test_customfields.py
--- a/netbox/extras/tests/test_customfields.py
+++ b/netbox/extras/tests/test_customfields.py
@@ -101,240 +101,329 @@ def test_select_field(self):
 
 class CustomFieldAPITest(APITestCase):
 
-    def setUp(self):
-
-        super().setUp()
-
+    @classmethod
+    def setUpTestData(cls):
         content_type = ContentType.objects.get_for_model(Site)
 
         # Text custom field
-        self.cf_text = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, name='magic_word')
-        self.cf_text.save()
-        self.cf_text.obj_type.set([content_type])
-        self.cf_text.save()
+        cls.cf_text = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, name='text_field', default='foo')
+        cls.cf_text.save()
+        cls.cf_text.obj_type.set([content_type])
 
         # Integer custom field
-        self.cf_integer = CustomField(type=CustomFieldTypeChoices.TYPE_INTEGER, name='magic_number')
-        self.cf_integer.save()
-        self.cf_integer.obj_type.set([content_type])
-        self.cf_integer.save()
+        cls.cf_integer = CustomField(type=CustomFieldTypeChoices.TYPE_INTEGER, name='number_field', default=123)
+        cls.cf_integer.save()
+        cls.cf_integer.obj_type.set([content_type])
 
         # Boolean custom field
-        self.cf_boolean = CustomField(type=CustomFieldTypeChoices.TYPE_BOOLEAN, name='is_magic')
-        self.cf_boolean.save()
-        self.cf_boolean.obj_type.set([content_type])
-        self.cf_boolean.save()
+        cls.cf_boolean = CustomField(type=CustomFieldTypeChoices.TYPE_BOOLEAN, name='boolean_field', default=False)
+        cls.cf_boolean.save()
+        cls.cf_boolean.obj_type.set([content_type])
 
         # Date custom field
-        self.cf_date = CustomField(type=CustomFieldTypeChoices.TYPE_DATE, name='magic_date')
-        self.cf_date.save()
-        self.cf_date.obj_type.set([content_type])
-        self.cf_date.save()
+        cls.cf_date = CustomField(type=CustomFieldTypeChoices.TYPE_DATE, name='date_field', default='2020-01-01')
+        cls.cf_date.save()
+        cls.cf_date.obj_type.set([content_type])
 
         # URL custom field
-        self.cf_url = CustomField(type=CustomFieldTypeChoices.TYPE_URL, name='magic_url')
-        self.cf_url.save()
-        self.cf_url.obj_type.set([content_type])
-        self.cf_url.save()
+        cls.cf_url = CustomField(type=CustomFieldTypeChoices.TYPE_URL, name='url_field', default='http://example.com/1')
+        cls.cf_url.save()
+        cls.cf_url.obj_type.set([content_type])
 
         # Select custom field
-        self.cf_select = CustomField(type=CustomFieldTypeChoices.TYPE_SELECT, name='magic_choice')
-        self.cf_select.save()
-        self.cf_select.obj_type.set([content_type])
-        self.cf_select.save()
-        self.cf_select_choice1 = CustomFieldChoice(field=self.cf_select, value='Foo')
-        self.cf_select_choice1.save()
-        self.cf_select_choice2 = CustomFieldChoice(field=self.cf_select, value='Bar')
-        self.cf_select_choice2.save()
-        self.cf_select_choice3 = CustomFieldChoice(field=self.cf_select, value='Baz')
-        self.cf_select_choice3.save()
-
-        self.site = Site.objects.create(name='Test Site 1', slug='test-site-1')
-
-    def test_get_obj_without_custom_fields(self):
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['name'], self.site.name)
-        self.assertEqual(response.data['custom_fields'], {
-            'magic_word': None,
-            'magic_number': None,
-            'is_magic': None,
-            'magic_date': None,
-            'magic_url': None,
-            'magic_choice': None,
-        })
-
-    def test_get_obj_with_custom_fields(self):
-
-        CUSTOM_FIELD_VALUES = [
-            (self.cf_text, 'Test string'),
-            (self.cf_integer, 1234),
-            (self.cf_boolean, True),
-            (self.cf_date, date(2016, 6, 23)),
-            (self.cf_url, 'http://example.com/'),
-            (self.cf_select, self.cf_select_choice1.pk),
-        ]
-        for field, value in CUSTOM_FIELD_VALUES:
-            cfv = CustomFieldValue(field=field, obj=self.site)
+        cls.cf_select = CustomField(type=CustomFieldTypeChoices.TYPE_SELECT, name='choice_field')
+        cls.cf_select.save()
+        cls.cf_select.obj_type.set([content_type])
+        cls.cf_select_choice1 = CustomFieldChoice(field=cls.cf_select, value='Foo')
+        cls.cf_select_choice1.save()
+        cls.cf_select_choice2 = CustomFieldChoice(field=cls.cf_select, value='Bar')
+        cls.cf_select_choice2.save()
+        cls.cf_select_choice3 = CustomFieldChoice(field=cls.cf_select, value='Baz')
+        cls.cf_select_choice3.save()
+
+        cls.cf_select.default = cls.cf_select_choice1.value
+        cls.cf_select.save()
+
+        # Create some sites
+        cls.sites = (
+            Site(name='Site 1', slug='site-1'),
+            Site(name='Site 2', slug='site-2'),
+        )
+        Site.objects.bulk_create(cls.sites)
+
+        # Assign custom field values for site 2
+        site2_cfvs = {
+            cls.cf_text: 'bar',
+            cls.cf_integer: 456,
+            cls.cf_boolean: True,
+            cls.cf_date: '2020-01-02',
+            cls.cf_url: 'http://example.com/2',
+            cls.cf_select: cls.cf_select_choice2.pk,
+        }
+        for field, value in site2_cfvs.items():
+            cfv = CustomFieldValue(field=field, obj=cls.sites[1])
             cfv.value = value
             cfv.save()
 
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
+    def test_get_single_object_without_custom_field_values(self):
+        """
+        Validate that custom fields are present on an object even if it has no values defined.
+        """
+        url = reverse('dcim-api:site-detail', kwargs={'pk': self.sites[0].pk})
         response = self.client.get(url, **self.header)
 
-        self.assertEqual(response.data['name'], self.site.name)
-        self.assertEqual(response.data['custom_fields'].get('magic_word'), CUSTOM_FIELD_VALUES[0][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_number'), CUSTOM_FIELD_VALUES[1][1])
-        self.assertEqual(response.data['custom_fields'].get('is_magic'), CUSTOM_FIELD_VALUES[2][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_date'), CUSTOM_FIELD_VALUES[3][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_url'), CUSTOM_FIELD_VALUES[4][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_choice'), {
-            'value': self.cf_select_choice1.pk, 'label': 'Foo'
+        self.assertEqual(response.data['name'], self.sites[0].name)
+        self.assertEqual(response.data['custom_fields'], {
+            'text_field': None,
+            'number_field': None,
+            'boolean_field': None,
+            'date_field': None,
+            'url_field': None,
+            'choice_field': None,
         })
 
-    def test_set_custom_field_text(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_word': 'Foo bar baz',
-            }
+    def test_get_single_object_with_custom_field_values(self):
+        """
+        Validate that custom fields are present and correctly set for an object with values defined.
+        """
+        site2_cfvs = {
+            cfv.field.name: cfv.value for cfv in self.sites[1].custom_field_values.all()
         }
 
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_word'), data['custom_fields']['magic_word'])
-        cfv = self.site.custom_field_values.get(field=self.cf_text)
-        self.assertEqual(cfv.value, data['custom_fields']['magic_word'])
+        url = reverse('dcim-api:site-detail', kwargs={'pk': self.sites[1].pk})
+        response = self.client.get(url, **self.header)
 
-    def test_set_custom_field_integer(self):
+        self.assertEqual(response.data['name'], self.sites[1].name)
+        self.assertEqual(response.data['custom_fields']['text_field'], site2_cfvs['text_field'])
+        self.assertEqual(response.data['custom_fields']['number_field'], site2_cfvs['number_field'])
+        self.assertEqual(response.data['custom_fields']['boolean_field'], site2_cfvs['boolean_field'])
+        self.assertEqual(response.data['custom_fields']['date_field'], site2_cfvs['date_field'])
+        self.assertEqual(response.data['custom_fields']['url_field'], site2_cfvs['url_field'])
+        self.assertEqual(response.data['custom_fields']['choice_field']['label'], self.cf_select_choice2.value)
 
+    def test_create_single_object_with_defaults(self):
+        """
+        Create a new site with no specified custom field values and check that it received the default values.
+        """
         data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_number': 42,
-            }
+            'name': 'Site 3',
+            'slug': 'site-3',
         }
 
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_number'), data['custom_fields']['magic_number'])
-        cfv = self.site.custom_field_values.get(field=self.cf_integer)
-        self.assertEqual(cfv.value, data['custom_fields']['magic_number'])
-
-    def test_set_custom_field_boolean(self):
+        url = reverse('dcim-api:site-list')
+        response = self.client.post(url, data, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
 
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'is_magic': 0,
-            }
+        # Validate response data
+        response_cf = response.data['custom_fields']
+        self.assertEqual(response_cf['text_field'], self.cf_text.default)
+        self.assertEqual(response_cf['number_field'], self.cf_integer.default)
+        self.assertEqual(response_cf['boolean_field'], self.cf_boolean.default)
+        self.assertEqual(response_cf['date_field'], self.cf_date.default)
+        self.assertEqual(response_cf['url_field'], self.cf_url.default)
+        self.assertEqual(response_cf['choice_field'], self.cf_select_choice1.pk)
+
+        # Validate database data
+        site = Site.objects.get(pk=response.data['id'])
+        cfvs = {
+            cfv.field.name: cfv.value for cfv in site.custom_field_values.all()
         }
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('is_magic'), data['custom_fields']['is_magic'])
-        cfv = self.site.custom_field_values.get(field=self.cf_boolean)
-        self.assertEqual(cfv.value, data['custom_fields']['is_magic'])
-
-    def test_set_custom_field_date(self):
-
+        self.assertEqual(cfvs['text_field'], self.cf_text.default)
+        self.assertEqual(cfvs['number_field'], self.cf_integer.default)
+        self.assertEqual(cfvs['boolean_field'], self.cf_boolean.default)
+        self.assertEqual(str(cfvs['date_field']), self.cf_date.default)
+        self.assertEqual(cfvs['url_field'], self.cf_url.default)
+        self.assertEqual(cfvs['choice_field'].pk, self.cf_select_choice1.pk)
+
+    def test_create_single_object_with_values(self):
+        """
+        Create a single new site with a value for each type of custom field.
+        """
         data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
+            'name': 'Site 3',
+            'slug': 'site-3',
             'custom_fields': {
-                'magic_date': '2017-04-25',
-            }
+                'text_field': 'bar',
+                'number_field': 456,
+                'boolean_field': True,
+                'date_field': '2020-01-02',
+                'url_field': 'http://example.com/2',
+                'choice_field': self.cf_select_choice2.pk,
+            },
         }
 
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_date'), data['custom_fields']['magic_date'])
-        cfv = self.site.custom_field_values.get(field=self.cf_date)
-        self.assertEqual(cfv.value.isoformat(), data['custom_fields']['magic_date'])
-
-    def test_set_custom_field_url(self):
+        url = reverse('dcim-api:site-list')
+        response = self.client.post(url, data, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
 
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_url': 'http://example.com/2/',
-            }
+        # Validate response data
+        response_cf = response.data['custom_fields']
+        data_cf = data['custom_fields']
+        self.assertEqual(response_cf['text_field'], data_cf['text_field'])
+        self.assertEqual(response_cf['number_field'], data_cf['number_field'])
+        self.assertEqual(response_cf['boolean_field'], data_cf['boolean_field'])
+        self.assertEqual(response_cf['date_field'], data_cf['date_field'])
+        self.assertEqual(response_cf['url_field'], data_cf['url_field'])
+        self.assertEqual(response_cf['choice_field'], data_cf['choice_field'])
+
+        # Validate database data
+        site = Site.objects.get(pk=response.data['id'])
+        cfvs = {
+            cfv.field.name: cfv.value for cfv in site.custom_field_values.all()
         }
+        self.assertEqual(cfvs['text_field'], data_cf['text_field'])
+        self.assertEqual(cfvs['number_field'], data_cf['number_field'])
+        self.assertEqual(cfvs['boolean_field'], data_cf['boolean_field'])
+        self.assertEqual(str(cfvs['date_field']), data_cf['date_field'])
+        self.assertEqual(cfvs['url_field'], data_cf['url_field'])
+        self.assertEqual(cfvs['choice_field'].pk, data_cf['choice_field'])
+
+    def test_create_multiple_objects_with_defaults(self):
+        """
+        Create three news sites with no specified custom field values and check that each received
+        the default custom field values.
+        """
+        data = (
+            {
+                'name': 'Site 3',
+                'slug': 'site-3',
+            },
+            {
+                'name': 'Site 4',
+                'slug': 'site-4',
+            },
+            {
+                'name': 'Site 5',
+                'slug': 'site-5',
+            },
+        )
 
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_url'), data['custom_fields']['magic_url'])
-        cfv = self.site.custom_field_values.get(field=self.cf_url)
-        self.assertEqual(cfv.value, data['custom_fields']['magic_url'])
-
-    def test_set_custom_field_select(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_choice': self.cf_select_choice2.pk,
+        url = reverse('dcim-api:site-list')
+        response = self.client.post(url, data, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data), len(data))
+
+        for i, obj in enumerate(data):
+
+            # Validate response data
+            response_cf = response.data[i]['custom_fields']
+            self.assertEqual(response_cf['text_field'], self.cf_text.default)
+            self.assertEqual(response_cf['number_field'], self.cf_integer.default)
+            self.assertEqual(response_cf['boolean_field'], self.cf_boolean.default)
+            self.assertEqual(response_cf['date_field'], self.cf_date.default)
+            self.assertEqual(response_cf['url_field'], self.cf_url.default)
+            self.assertEqual(response_cf['choice_field'], self.cf_select_choice1.pk)
+
+            # Validate database data
+            site = Site.objects.get(pk=response.data[i]['id'])
+            cfvs = {
+                cfv.field.name: cfv.value for cfv in site.custom_field_values.all()
             }
+            self.assertEqual(cfvs['text_field'], self.cf_text.default)
+            self.assertEqual(cfvs['number_field'], self.cf_integer.default)
+            self.assertEqual(cfvs['boolean_field'], self.cf_boolean.default)
+            self.assertEqual(str(cfvs['date_field']), self.cf_date.default)
+            self.assertEqual(cfvs['url_field'], self.cf_url.default)
+            self.assertEqual(cfvs['choice_field'].pk, self.cf_select_choice1.pk)
+
+    def test_create_multiple_objects_with_values(self):
+        """
+        Create a three new sites, each with custom fields defined.
+        """
+        custom_field_data = {
+            'text_field': 'bar',
+            'number_field': 456,
+            'boolean_field': True,
+            'date_field': '2020-01-02',
+            'url_field': 'http://example.com/2',
+            'choice_field': self.cf_select_choice2.pk,
         }
+        data = (
+            {
+                'name': 'Site 3',
+                'slug': 'site-3',
+                'custom_fields': custom_field_data,
+            },
+            {
+                'name': 'Site 4',
+                'slug': 'site-4',
+                'custom_fields': custom_field_data,
+            },
+            {
+                'name': 'Site 5',
+                'slug': 'site-5',
+                'custom_fields': custom_field_data,
+            },
+        )
 
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_choice'), data['custom_fields']['magic_choice'])
-        cfv = self.site.custom_field_values.get(field=self.cf_select)
-        self.assertEqual(cfv.value.pk, data['custom_fields']['magic_choice'])
-
-    def test_set_custom_field_defaults(self):
+        url = reverse('dcim-api:site-list')
+        response = self.client.post(url, data, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data), len(data))
+
+        for i, obj in enumerate(data):
+
+            # Validate response data
+            response_cf = response.data[i]['custom_fields']
+            self.assertEqual(response_cf['text_field'], custom_field_data['text_field'])
+            self.assertEqual(response_cf['number_field'], custom_field_data['number_field'])
+            self.assertEqual(response_cf['boolean_field'], custom_field_data['boolean_field'])
+            self.assertEqual(response_cf['date_field'], custom_field_data['date_field'])
+            self.assertEqual(response_cf['url_field'], custom_field_data['url_field'])
+            self.assertEqual(response_cf['choice_field'], custom_field_data['choice_field'])
+
+            # Validate database data
+            site = Site.objects.get(pk=response.data[i]['id'])
+            cfvs = {
+                cfv.field.name: cfv.value for cfv in site.custom_field_values.all()
+            }
+            self.assertEqual(cfvs['text_field'], custom_field_data['text_field'])
+            self.assertEqual(cfvs['number_field'], custom_field_data['number_field'])
+            self.assertEqual(cfvs['boolean_field'], custom_field_data['boolean_field'])
+            self.assertEqual(str(cfvs['date_field']), custom_field_data['date_field'])
+            self.assertEqual(cfvs['url_field'], custom_field_data['url_field'])
+            self.assertEqual(cfvs['choice_field'].pk, custom_field_data['choice_field'])
+
+    def test_update_single_object_with_values(self):
         """
-        Create a new object with no custom field data. Custom field values should be created using the custom fields'
-        default values.
+        Update an object with existing custom field values. Ensure that only the updated custom field values are
+        modified.
         """
-        CUSTOM_FIELD_DEFAULTS = {
-            'magic_word': 'foobar',
-            'magic_number': '123',
-            'is_magic': 'true',
-            'magic_date': '2019-12-13',
-            'magic_url': 'http://example.com/',
-            'magic_choice': self.cf_select_choice1.value,
+        site2_original_cfvs = {
+            cfv.field.name: cfv.value for cfv in self.sites[1].custom_field_values.all()
         }
-
-        # Update CustomFields to set default values
-        for field_name, default_value in CUSTOM_FIELD_DEFAULTS.items():
-            CustomField.objects.filter(name=field_name).update(default=default_value)
-
         data = {
-            'name': 'Test Site X',
-            'slug': 'test-site-x',
+            'custom_fields': {
+                'text_field': 'ABCD',
+                'number_field': 1234,
+            },
         }
 
-        url = reverse('dcim-api:site-list')
-        response = self.client.post(url, data, format='json', **self.header)
+        url = reverse('dcim-api:site-detail', kwargs={'pk': self.sites[1].pk})
+        response = self.client.patch(url, data, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
 
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(response.data['custom_fields']['magic_word'], CUSTOM_FIELD_DEFAULTS['magic_word'])
-        self.assertEqual(response.data['custom_fields']['magic_number'], str(CUSTOM_FIELD_DEFAULTS['magic_number']))
-        self.assertEqual(response.data['custom_fields']['is_magic'], bool(CUSTOM_FIELD_DEFAULTS['is_magic']))
-        self.assertEqual(response.data['custom_fields']['magic_date'], CUSTOM_FIELD_DEFAULTS['magic_date'])
-        self.assertEqual(response.data['custom_fields']['magic_url'], CUSTOM_FIELD_DEFAULTS['magic_url'])
-        self.assertEqual(response.data['custom_fields']['magic_choice'], self.cf_select_choice1.pk)
+        # Validate response data
+        response_cf = response.data['custom_fields']
+        data_cf = data['custom_fields']
+        self.assertEqual(response_cf['text_field'], data_cf['text_field'])
+        self.assertEqual(response_cf['number_field'], data_cf['number_field'])
+        # TODO: Non-updated fields are missing from the response data
+        # self.assertEqual(response_cf['boolean_field'], site2_original_cfvs['boolean_field'])
+        # self.assertEqual(response_cf['date_field'], site2_original_cfvs['date_field'])
+        # self.assertEqual(response_cf['url_field'], site2_original_cfvs['url_field'])
+        # self.assertEqual(response_cf['choice_field']['label'], site2_original_cfvs['choice_field'].value)
+
+        # Validate database data
+        site2_updated_cfvs = {
+            cfv.field.name: cfv.value for cfv in self.sites[1].custom_field_values.all()
+        }
+        self.assertEqual(site2_updated_cfvs['text_field'], data_cf['text_field'])
+        self.assertEqual(site2_updated_cfvs['number_field'], data_cf['number_field'])
+        self.assertEqual(site2_updated_cfvs['boolean_field'], site2_original_cfvs['boolean_field'])
+        self.assertEqual(site2_updated_cfvs['date_field'], site2_original_cfvs['date_field'])
+        self.assertEqual(site2_updated_cfvs['url_field'], site2_original_cfvs['url_field'])
+        self.assertEqual(site2_updated_cfvs['choice_field'], site2_original_cfvs['choice_field'])
 
 
 class CustomFieldChoiceAPITest(APITestCase):