diff --git a/.gitignore b/.gitignore
index 3df3c9e4..01e9cedd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
+# Editors
+.vscode
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
diff --git a/SETUP.md b/SETUP.md
index f4b3210a..a5122f70 100644
--- a/SETUP.md
+++ b/SETUP.md
@@ -91,4 +91,17 @@ host machine.
 
    The `jupyterhub_config.py` file that ships in this repo will read that environment variable to figure out what IP the pods should connect to the JupyterHub on. Replace `vboxnet4` with whatever interface name you used in step 4 of the previous section.
 
-This will give you a running JupyterHub that spawns nodes inside the minikube VM! It'll be setup with [DummyAuthenticator](http://github.com/yuvipanda/jupyterhub-dummy-authenticator), so any user + password combo will allow you to log in. You can make changes to the spawner and restart jupyterhub, and rapidly iterate :)
+   This will give you a running JupyterHub that spawns nodes inside the minikube VM! It'll be setup with [DummyAuthenticator](http://github.com/yuvipanda/jupyterhub-dummy-authenticator), so any user + password combo will allow you to log in. You can make changes to the spawner and restart jupyterhub, and rapidly iterate :)
+
+## Running tests
+
+```
+python setup.py test
+```
+
+If you got a massive amount of errors, it may help to remove your .eggs
+directory.
+
+```
+rm -rf .eggs
+```
\ No newline at end of file
diff --git a/kubespawner/objects.py b/kubespawner/objects.py
index 3c6f5f2e..3c2a6527 100644
--- a/kubespawner/objects.py
+++ b/kubespawner/objects.py
@@ -6,19 +6,24 @@
 import escapism
 import re
 import string
+from kubespawner.utils import get_k8s_model, update_k8s_model
 
 from kubernetes.client.models import (
     V1Pod, V1PodSpec, V1PodSecurityContext,
     V1ObjectMeta,
     V1LocalObjectReference,
     V1Volume, V1VolumeMount,
-    V1Container, V1ContainerPort, V1SecurityContext, V1EnvVar, V1ResourceRequirements,
+    V1Container, V1ContainerPort, V1SecurityContext, V1EnvVar, V1ResourceRequirements, V1Lifecycle,
     V1PersistentVolumeClaim, V1PersistentVolumeClaimSpec,
     V1Endpoints, V1EndpointSubset, V1EndpointAddress, V1EndpointPort,
     V1Service, V1ServiceSpec, V1ServicePort,
     V1beta1Ingress, V1beta1IngressSpec, V1beta1IngressRule,
     V1beta1HTTPIngressRuleValue, V1beta1HTTPIngressPath,
-    V1beta1IngressBackend
+    V1beta1IngressBackend,
+    V1Toleration,
+    V1Affinity,
+    V1NodeAffinity, V1NodeSelector, V1NodeSelectorTerm, V1PreferredSchedulingTerm, V1NodeSelectorRequirement,
+    V1PodAffinity, V1PodAntiAffinity, V1WeightedPodAffinityTerm, V1PodAffinityTerm,
 )
 
 def make_pod(
@@ -34,12 +39,12 @@ def make_pod(
     fs_gid=None,
     supplemental_gids=None,
     run_privileged=False,
-    env={},
+    env=None,
     working_dir=None,
-    volumes=[],
-    volume_mounts=[],
-    labels={},
-    annotations={},
+    volumes=None,
+    volume_mounts=None,
+    labels=None,
+    annotations=None,
     cpu_limit=None,
     cpu_guarantee=None,
     mem_limit=None,
@@ -52,7 +57,16 @@ def make_pod(
     extra_container_config=None,
     extra_pod_config=None,
     extra_containers=None,
-    scheduler_name=None
+    scheduler_name=None,
+    tolerations=None,
+    node_affinity_preferred=None,
+    node_affinity_required=None,
+    pod_affinity_preferred=None,
+    pod_affinity_required=None,
+    pod_anti_affinity_preferred=None,
+    pod_anti_affinity_required=None,
+    priority_class_name=None,
+    logger=None,
 ):
     """
     Make a k8s pod specification for running a user notebook.
@@ -143,17 +157,73 @@ def make_pod(
     extra_containers:
         Extra containers besides notebook container. Used for some housekeeping jobs (e.g. crontab).
     scheduler_name:
-        A custom scheduler's name.
+        The pod's scheduler explicitly named.
+    tolerations:
+        Tolerations can allow a pod to schedule or execute on a tainted node. To
+        learn more about pod tolerations, see
+        https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/.
+
+        Pass this field an array of "Toleration" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#nodeselectorterm-v1-core
+    node_affinity_preferred:
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "PreferredSchedulingTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#preferredschedulingterm-v1-core
+    node_affinity_required:
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "NodeSelectorTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#nodeselectorterm-v1-core
+    pod_affinity_preferred:
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "WeightedPodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#weightedpodaffinityterm-v1-core
+    pod_affinity_required:
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "PodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#podaffinityterm-v1-core
+    pod_anti_affinity_preferred:
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "WeightedPodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#weightedpodaffinityterm-v1-core
+    pod_anti_affinity_required:
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "PodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#podaffinityterm-v1-core
+    priority_class_name:
+        The name of the PriorityClass to be assigned the pod. This feature is Beta available in K8s 1.11.
     """
-
     pod = V1Pod()
     pod.kind = "Pod"
     pod.api_version = "v1"
 
     pod.metadata = V1ObjectMeta(
         name=name,
-        labels=labels.copy(),
-        annotations=annotations.copy()
+        labels=(labels or {}).copy(),
+        annotations=(annotations or {}).copy()
     )
 
     pod.spec = V1PodSpec(containers=[])
@@ -179,17 +249,20 @@ def make_pod(
     if node_selector:
         pod.spec.node_selector = node_selector
 
+    if lifecycle_hooks:
+        lifecycle_hooks = get_k8s_model(V1Lifecycle, lifecycle_hooks)
+
     notebook_container = V1Container(
         name='notebook',
         image=image_spec,
         working_dir=working_dir,
         ports=[V1ContainerPort(name='notebook-port', container_port=port)],
-        env=[V1EnvVar(k, v) for k, v in env.items()],
+        env=[V1EnvVar(k, v) for k, v in (env or {}).items()],
         args=cmd,
         image_pull_policy=image_pull_policy,
         lifecycle=lifecycle_hooks,
         resources=V1ResourceRequirements(),
-        volume_mounts=volume_mounts
+        volume_mounts=[get_k8s_model(V1VolumeMount, obj) for obj in (volume_mounts or [])],
     )
 
     if service_account is None:
@@ -200,9 +273,7 @@ def make_pod(
         pod.spec.service_account_name = service_account
 
     if run_privileged:
-        notebook_container.security_context = V1SecurityContext(
-            privileged=True
-        )
+        notebook_container.security_context = V1SecurityContext(privileged=True)
 
     notebook_container.resources.requests = {}
     if cpu_guarantee:
@@ -210,8 +281,7 @@ def make_pod(
     if mem_guarantee:
         notebook_container.resources.requests['memory'] = mem_guarantee
     if extra_resource_guarantees:
-        for k in extra_resource_guarantees:
-            notebook_container.resources.requests[k] = extra_resource_guarantees[k]
+        notebook_container.resources.requests.update(extra_resource_guarantees)
 
     notebook_container.resources.limits = {}
     if cpu_limit:
@@ -219,38 +289,103 @@ def make_pod(
     if mem_limit:
         notebook_container.resources.limits['memory'] = mem_limit
     if extra_resource_limits:
-        for k in extra_resource_limits:
-            notebook_container.resources.limits[k] = extra_resource_limits[k]
-
-    pod.spec.containers.append(notebook_container)
+        notebook_container.resources.limits.update(extra_resource_limits)
 
     if extra_container_config:
-        for key, value in extra_container_config.items():
-            setattr(notebook_container, _map_attribute(notebook_container.attribute_map, key), value)
-    if extra_pod_config:
-        for key, value in extra_pod_config.items():
-            setattr(pod.spec, _map_attribute(pod.spec.attribute_map, key), value)
-    if extra_containers:
-        pod.spec.containers.extend(extra_containers)
+        notebook_container = update_k8s_model(
+            target=notebook_container,
+            source=extra_container_config,
+            logger=logger,
+            origin="extra_container_config",
+        )
 
-    pod.spec.init_containers = init_containers
-    pod.spec.volumes = volumes
+    pod.spec.containers.append(notebook_container)
 
+    if extra_containers:
+        pod.spec.containers.extend([get_k8s_model(V1Container, obj) for obj in extra_containers])
+    if tolerations:
+        pod.spec.tolerations = [get_k8s_model(V1Toleration, obj) for obj in tolerations]
+    if init_containers:
+        pod.spec.init_containers = [get_k8s_model(V1Container, obj) for obj in init_containers]
+    if volumes:
+        pod.spec.volumes = [get_k8s_model(V1Volume, obj) for obj in volumes]
+    else:
+        # Keep behaving exactly like before by not cleaning up generated pod
+        # spec by setting the volumes field even though it is an empty list.
+        pod.spec.volumes = []
     if scheduler_name:
         pod.spec.scheduler_name = scheduler_name
 
-    return pod
+    node_affinity = None
+    if node_affinity_preferred or node_affinity_required:
+        node_selector = None
+        if node_affinity_required:
+            node_selector = V1NodeSelector(
+                node_selector_terms=[get_k8s_model(V1NodeSelectorTerm, obj) for obj in node_affinity_required],
+            )
+
+        preferred_scheduling_terms = None
+        if node_affinity_preferred:
+            preferred_scheduling_terms = [get_k8s_model(V1PreferredSchedulingTerm, obj) for obj in node_affinity_preferred]
 
+        node_affinity = V1NodeAffinity(
+            preferred_during_scheduling_ignored_during_execution=preferred_scheduling_terms,
+            required_during_scheduling_ignored_during_execution=node_selector,
+        )
 
-def _map_attribute(attribute_map, attribute):
-    if attribute in attribute_map:
-        return attribute
+    pod_affinity = None
+    if pod_affinity_preferred or pod_affinity_required:
+        weighted_pod_affinity_terms = None
+        if pod_affinity_preferred:
+            weighted_pod_affinity_terms = [get_k8s_model(V1WeightedPodAffinityTerm, obj) for obj in pod_affinity_preferred]
 
-    for key, value in attribute_map.items():
-        if value == attribute:
-            return key
-    else:
-        raise ValueError('Attribute must be one of {}'.format(attribute_map.values()))
+        pod_affinity_terms = None
+        if pod_affinity_required:
+            pod_affinity_terms = [get_k8s_model(V1PodAffinityTerm, obj) for obj in pod_affinity_required]
+
+        pod_affinity = V1PodAffinity(
+            preferred_during_scheduling_ignored_during_execution=weighted_pod_affinity_terms,
+            required_during_scheduling_ignored_during_execution=pod_affinity_terms,
+        )
+
+    pod_anti_affinity = None
+    if pod_anti_affinity_preferred or pod_anti_affinity_required:
+        weighted_pod_affinity_terms = None
+        if pod_anti_affinity_preferred:
+            weighted_pod_affinity_terms = [get_k8s_model(V1WeightedPodAffinityTerm, obj) for obj in pod_anti_affinity_preferred]
+
+        pod_affinity_terms = None
+        if pod_anti_affinity_required:
+            pod_affinity_terms = [get_k8s_model(V1PodAffinityTerm, obj) for obj in pod_anti_affinity_required]
+
+        pod_anti_affinity = V1PodAffinity(
+            preferred_during_scheduling_ignored_during_execution=weighted_pod_affinity_terms,
+            required_during_scheduling_ignored_during_execution=pod_affinity_terms,
+        )
+
+    affinity = None
+    if (node_affinity or pod_affinity or pod_anti_affinity):
+        affinity = V1Affinity(
+            node_affinity=node_affinity,
+            pod_affinity=pod_affinity,
+            pod_anti_affinity=pod_anti_affinity,
+        )
+
+    if affinity:
+        pod.spec.affinity = affinity
+
+    if priority_class_name:
+        pod.spec.priority_class_name = priority_class_name
+
+    if extra_pod_config:
+        pod.spec = update_k8s_model(
+            target=pod.spec,
+            source=extra_pod_config,
+            logger=logger,
+            origin="extra_pod_config",
+        )
+
+    return pod
 
 
 def make_pvc(
@@ -258,8 +393,8 @@ def make_pvc(
     storage_class,
     access_modes,
     storage,
-    labels,
-    annotations={}
+    labels=None,
+    annotations=None
     ):
     """
     Make a k8s pvc specification for running a user notebook.
@@ -282,9 +417,8 @@ def make_pvc(
     pvc.api_version = "v1"
     pvc.metadata = V1ObjectMeta()
     pvc.metadata.name = name
-    pvc.metadata.annotations = annotations
-    pvc.metadata.labels = {}
-    pvc.metadata.labels.update(labels)
+    pvc.metadata.annotations = (annotations or {}).copy()
+    pvc.metadata.labels = (labels or {}).copy()
     pvc.spec = V1PersistentVolumeClaimSpec()
     pvc.spec.access_modes = access_modes
     pvc.spec.resources = V1ResourceRequirements()
diff --git a/kubespawner/spawner.py b/kubespawner/spawner.py
index abc14272..10afe543 100644
--- a/kubespawner/spawner.py
+++ b/kubespawner/spawner.py
@@ -16,7 +16,7 @@
 from tornado import gen
 from tornado.ioloop import IOLoop
 from tornado.concurrent import run_on_executor
-from traitlets import Any, Unicode, List, Integer, Union, Dict, Bool, Any, validate
+from traitlets import Any, Unicode, List, Integer, Union, Dict, Bool, Any, validate, default
 from jupyterhub.spawner import Spawner
 from jupyterhub.utils import exponential_backoff
 from jupyterhub.traitlets import Command
@@ -63,6 +63,9 @@ def events(self):
         )
 
 
+class MockObject(object):
+    pass
+
 class KubeSpawner(Spawner):
     """
     Implement a JupyterHub spawner to spawn pods in a Kubernetes Cluster.
@@ -90,37 +93,50 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         if _mock:
-            # if testing, skip the rest of initialization
-            # FIXME: rework initialization for easier mocking
-            return
+            # runs during test execution only
+            user = MockObject()
+            user.name = 'mock_name'
+            user.id = 'mock_id'
+            user.url = 'mock_url'
+            self.user = user
+
+            hub = MockObject()
+            hub.public_host = 'mock_public_host'
+            hub.url = 'mock_url'
+            hub.base_url = 'mock_base_url'
+            hub.api_url = 'mock_api_url'
+            self.hub = hub
+        else:
+            # runs during normal execution only
 
-        # By now, all the traitlets have been set, so we can use them to compute
-        # other attributes
-        if self.__class__.executor is None:
-            self.__class__.executor = ThreadPoolExecutor(
-                max_workers=self.k8s_api_threadpool_workers
-            )
+            # By now, all the traitlets have been set, so we can use them to compute
+            # other attributes
+            if self.__class__.executor is None:
+                self.__class__.executor = ThreadPoolExecutor(
+                    max_workers=self.k8s_api_threadpool_workers
+                )
 
-        # This will start watching in __init__, so it'll start the first
-        # time any spawner object is created. Not ideal but works!
-        self._start_watching_pods()
-        if self.events_enabled:
-            self._start_watching_events()
+            # This will start watching in __init__, so it'll start the first
+            # time any spawner object is created. Not ideal but works!
+            self._start_watching_pods()
+            if self.events_enabled:
+                self._start_watching_events()
 
-        self.api = shared_client('CoreV1Api')
+            self.api = shared_client('CoreV1Api')
 
+            if self.hub_connect_ip:
+                scheme, netloc, path, params, query, fragment = urlparse(self.hub.api_url)
+                netloc = '{ip}:{port}'.format(
+                    ip=self.hub_connect_ip,
+                    port=self.hub_connect_port,
+                )
+                self.accessible_hub_api_url = urlunparse((scheme, netloc, path, params, query, fragment))
+            else:
+                self.accessible_hub_api_url = self.hub.api_url
+
+        # runs during both test and normal execution
         self.pod_name = self._expand_user_properties(self.pod_name_template)
         self.pvc_name = self._expand_user_properties(self.pvc_name_template)
-        if self.hub_connect_ip:
-            scheme, netloc, path, params, query, fragment = urlparse(self.hub.api_url)
-            netloc = '{ip}:{port}'.format(
-                ip=self.hub_connect_ip,
-                port=self.hub_connect_port,
-            )
-            self.accessible_hub_api_url = urlunparse((scheme, netloc, path, params, query, fragment))
-        else:
-            self.accessible_hub_api_url = self.hub.api_url
-
         if self.port == 0:
             # Our default port is 8888
             self.port = 8888
@@ -128,8 +144,7 @@ def __init__(self, *args, **kwargs):
     k8s_api_threadpool_workers = Integer(
         # Set this explicitly, since this is the default in Python 3.5+
         # but not in 3.4
-        5 * multiprocessing.cpu_count(),
-        config=True,
+        default_value=5 * multiprocessing.cpu_count(),
         help="""
         Number of threads in thread pool used to talk to the k8s API.
 
@@ -137,29 +152,28 @@ def __init__(self, *args, **kwargs):
 
         Defaults to `5 * cpu_cores`, which is the default for `ThreadPoolExecutor`.
         """
-    )
+    ).tag(config=True)
 
     events_enabled = Bool(
-        True,
-        config=True,
+        default_value=True,
         help="""
         Enable event-watching for progress-reports to the user spawn page.
 
         Disable if these events are not desirable
         or to save some performance cost.
         """
-        )
+    ).tag(config=True)
 
     namespace = Unicode(
-        config=True,
         help="""
         Kubernetes namespace to spawn user pods in.
 
         If running inside a kubernetes cluster with service accounts enabled,
         defaults to the current namespace. If not, defaults to `default`
         """
-    )
+    ).tag(config=True)
 
+    @default('namespace')
     def _namespace_default(self):
         """
         Set namespace default to current namespace if running in a k8s cluster
@@ -173,7 +187,8 @@ def _namespace_default(self):
                 return f.read().strip()
         return 'default'
 
-    ip = Unicode('0.0.0.0',
+    ip = Unicode(
+        default_value='0.0.0.0',
         help="""
         The IP address (or hostname) the single-user server should listen on.
 
@@ -183,7 +198,7 @@ def _namespace_default(self):
     ).tag(config=True)
 
     cmd = Command(
-        None,
+        default_value=None,
         allow_none=True,
         minlen=0,
         help="""
@@ -203,7 +218,7 @@ def _namespace_default(self):
     ).tag(config=True)
 
     working_dir = Unicode(
-        None,
+        default_value=None,
         allow_none=True,
         help="""
         The working directory where the Notebook server will be started inside the container.
@@ -212,9 +227,8 @@ def _namespace_default(self):
     ).tag(config=True)
 
     service_account = Unicode(
-        None,
+        default_value=None,
         allow_none=True,
-        config=True,
         help="""
         The service account to be mounted in the spawned user pod.
 
@@ -227,11 +241,10 @@ def _namespace_default(self):
         has the minimal permissions needed, and nothing more. When misconfigured, this can easily
         give arbitrary users root over your entire cluster.
         """
-    )
+    ).tag(config=True)
 
     pod_name_template = Unicode(
-        'jupyter-{username}{servername}',
-        config=True,
+        default_value='jupyter-{username}{servername}',
         help="""
         Template to use to form the name of user's pods.
 
@@ -242,22 +255,20 @@ def _namespace_default(self):
         in, so if you are running multiple jupyterhubs spawning in the
         same namespace, consider setting this to be something more unique.
         """
-    )
+    ).tag(config=True)
 
     storage_pvc_ensure = Bool(
-        False,
-        config=True,
+        default_value=False,
         help="""
         Ensure that a PVC exists for each user before spawning.
 
         Set to true to create a PVC named with `pvc_name_template` if it does
         not exist for the user when their pod is spawning.
         """
-    )
+    ).tag(config=True)
 
     pvc_name_template = Unicode(
-        'claim-{username}{servername}',
-        config=True,
+        default_value='claim-{username}{servername}',
         help="""
         Template to use to form the name of user's pvc.
 
@@ -268,11 +279,10 @@ def _namespace_default(self):
         in, so if you are running multiple jupyterhubs spawning in the
         same namespace, consider setting this to be something more unique.
         """
-    )
+    ).tag(config=True)
 
     hub_connect_ip = Unicode(
-        None,
-        config=True,
+        default_value=None,
         allow_none=True,
         help="""
         IP/DNS hostname to be used by pods to reach out to the hub API.
@@ -290,10 +300,9 @@ def _namespace_default(self):
 
         Used together with `hub_connect_port` configuration.
         """
-    )
+    ).tag(config=True)
 
     hub_connect_port = Integer(
-        config=True,
         help="""
         Port to use by pods to reach out to the hub API.
 
@@ -306,8 +315,9 @@ def _namespace_default(self):
         This should be set to the `port` attribute of a service that is
         fronting the hub pod.
         """
-    )
+    ).tag(config=True)
 
+    @default('hub_connect_port')
     def _hub_connect_port_default(self):
         """
         Set default port on which pods connect to hub to be the hub port
@@ -319,11 +329,10 @@ def _hub_connect_port_default(self):
         return self.hub.server.port
 
     common_labels = Dict(
-        {
+        default_value={
             'app': 'jupyterhub',
             'heritage': 'jupyterhub',
         },
-        config=True,
         help="""
         Kubernetes labels that both spawned singleuser server pods and created
         user PVCs will get.
@@ -331,11 +340,10 @@ def _hub_connect_port_default(self):
         Note that these are only set when the Pods and PVCs are created, not
         later when this setting is updated.
         """
-    )
+    ).tag(config=True)
 
     extra_labels = Dict(
-        {},
-        config=True,
+        default_value={},
         help="""
         Extra kubernetes labels to set on the spawned single-user pods.
 
@@ -349,11 +357,10 @@ def _hub_connect_port_default(self):
         `{username}` and `{userid}` are expanded to the escaped, dns-label safe
         username & integer user id respectively, wherever they are used.
         """
-    )
+    ).tag(config=True)
 
     extra_annotations = Dict(
-        {},
-        config=True,
+        default_value={},
         help="""
         Extra kubernetes annotations to set on the spawned single-user pods.
 
@@ -366,11 +373,10 @@ def _hub_connect_port_default(self):
         `{username}` and `{userid}` are expanded to the escaped, dns-label safe
         username & integer user id respectively, wherever they are used.
         """
-    )
+    ).tag(config=True)
 
     image_spec = Unicode(
-        'jupyterhub/singleuser:latest',
-        config=True,
+        default_value='jupyterhub/singleuser:latest',
         help="""
         Docker image spec to use for spawning user's containers.
 
@@ -394,11 +400,10 @@ def _hub_connect_port_default(self):
            c.KubeSpawner.start_timeout = 60 * 5  # Upto 5 minutes
 
         """
-    )
+    ).tag(config=True)
 
     image_pull_policy = Unicode(
-        'IfNotPresent',
-        config=True,
+        default_value='IfNotPresent',
         help="""
         The image pull policy of the docker container specified in
         `image_spec`.
@@ -412,12 +417,11 @@ def _hub_connect_port_default(self):
         actively changing the `image_spec` and would like to pull the image
         whenever a user container is spawned.
         """
-    )
+    ).tag(config=True)
 
     image_pull_secrets = Unicode(
-        None,
+        default_value=None,
         allow_none=True,
-        config=True,
         help="""
         The kubernetes secret to use for pulling images from private repository.
 
@@ -428,11 +432,10 @@ def _hub_connect_port_default(self):
         has more information on when and why this might need to be set, and what it
         should be set to.
         """
-    )
+    ).tag(config=True)
 
     node_selector = Dict(
-        {},
-        config=True,
+        default_value={},
         help="""
         The dictionary Selector labels used to match the Nodes where Pods will be launched.
 
@@ -442,15 +445,14 @@ def _hub_connect_port_default(self):
 
             {"disktype": "ssd"}
         """
-    )
+    ).tag(config=True)
 
     uid = Union(
-        [
+        trait_types=[
             Integer(),
             Callable(),
         ],
         allow_none=True,
-        config=True,
         help="""
         The UID to run the single-user server containers as.
 
@@ -467,15 +469,14 @@ def _hub_connect_port_default(self):
         If set to `None`, the user specified with the `USER` directive in the
         container metadata is used.
         """
-    )
+    ).tag(config=True)
 
     gid = Union(
-        [
+        trait_types=[
             Integer(),
             Callable(),
         ],
         allow_none=True,
-        config=True,
         help="""
         The GID to run the single-user server containers as.
 
@@ -492,15 +493,14 @@ def _hub_connect_port_default(self):
         If set to `None`, the group of the user specified with the `USER` directive
         in the container metadata is used.
         """
-    )
+    ).tag(config=True)
 
     fs_gid = Union(
-        [
+        trait_types=[
             Integer(),
             Callable(),
         ],
         allow_none=True,
-        config=True,
         help="""
         The GID of the group that should own any volumes that are created & mounted.
 
@@ -527,15 +527,14 @@ def _hub_connect_port_default(self):
         cloud providers. See `fsGroup <https://kubernetes.io/docs/api-reference/v1.9/#podsecuritycontext-v1-core>`_
         for more details.
         """
-    )
+    ).tag(config=True)
 
     supplemental_gids = Union(
-        [
+        trait_types=[
             List(),
             Callable(),
         ],
         allow_none=True,
-        config=True,
         help="""
         A list of GIDs that should be set as additional supplemental groups to the
         user that the container runs as.
@@ -554,20 +553,18 @@ def _hub_connect_port_default(self):
         image must setup all directories/files any application needs access to, as group
         writable.
         """
-    )
+    ).tag(config=True)
 
     privileged = Bool(
-        False,
-        config=True,
+        default_value=False,
         help="""
         Whether to run the pod with a privileged security context.
         """
-    )
+    ).tag(config=True)
 
     modify_pod_hook = Callable(
-        None,
+        default_value=None,
         allow_none=True,
-        config=True,
         help="""
         Callable to augment the Pod object before launching.
 
@@ -584,11 +581,10 @@ def _hub_connect_port_default(self):
         Note that the spawner object can change between versions of KubeSpawner and JupyterHub,
         so be careful relying on this!
         """
-    )
+    ).tag(config=True)
 
     volumes = List(
-        [],
-        config=True,
+        default_value=[],
         help="""
         List of Kubernetes Volume specifications that will be mounted in the user pod.
 
@@ -612,11 +608,10 @@ def _hub_connect_port_default(self):
         `{username}` and `{userid}` are expanded to the escaped, dns-label safe
         username & integer user id respectively, wherever they are used.
         """
-    )
+    ).tag(config=True)
 
     volume_mounts = List(
-        [],
-        config=True,
+        default_value=[],
         help="""
         List of paths on which to mount volumes in the user notebook's pod.
 
@@ -633,11 +628,10 @@ def _hub_connect_port_default(self):
         `{username}` and `{userid}` are expanded to the escaped, dns-label safe
         username & integer user id respectively, wherever they are used.
         """
-    )
+    ).tag(config=True)
 
     storage_capacity = Unicode(
-        None,
-        config=True,
+        default_value=None,
         allow_none=True,
         help="""
         The ammount of storage space to request from the volume that the pvc will
@@ -656,11 +650,10 @@ def _hub_connect_port_default(self):
         the same value: `128974848`, `129e6`, `129M`, `123Mi`.
         (https://github.com/kubernetes/kubernetes/blob/master/docs/design/resources.md)
         """
-    )
+    ).tag(config=True)
 
     storage_extra_labels = Dict(
-        {},
-        config=True,
+        default_value={},
         help="""
         Extra kubernetes labels to set on the user PVCs.
 
@@ -674,11 +667,10 @@ def _hub_connect_port_default(self):
         `{username}` and `{userid}` are expanded to the escaped, dns-label safe
         username & integer user id respectively, wherever they are used.
         """
-    )
+    ).tag(config=True)
 
     storage_class = Unicode(
-        None,
-        config=True,
+        default_value=None,
         allow_none=True,
         help="""
         The storage class that the pvc will use. If left blank, the kubespawner will not
@@ -696,11 +688,10 @@ def _hub_connect_port_default(self):
         more information on how StorageClasses work.
 
         """
-    )
+    ).tag(config=True)
 
     storage_access_modes = List(
-        ["ReadWriteOnce"],
-        config=True,
+        default_value=["ReadWriteOnce"],
         help="""
         List of access modes the user has for the pvc.
 
@@ -713,11 +704,10 @@ def _hub_connect_port_default(self):
         See https://kubernetes.io/docs/concepts/storage/persistent-volumes/#access-modes for
         more information on how access modes work.
         """
-    )
+    ).tag(config=True)
 
     lifecycle_hooks = Dict(
-        {},
-        config=True,
+        default_value={},
         help="""
         Kubernetes lifecycle hooks to set on the spawned single-user pods.
 
@@ -738,11 +728,10 @@ def _hub_connect_port_default(self):
         See https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/ for more
         info on what lifecycle hooks are and why you might want to use them!
         """
-    )
+    ).tag(config=True)
 
     init_containers = List(
-        None,
-        config=True,
+        default_value=[],
         help="""
         List of initialization containers belonging to the pod.
 
@@ -769,11 +758,10 @@ def _hub_connect_port_default(self):
 
         To user this feature, Kubernetes version must greater than 1.6.
         """
-    )
+    ).tag(config=True)
 
     extra_container_config = Dict(
-        None,
-        config=True,
+        default_value={},
         help="""
         Extra configuration (e.g. ``envFrom``) for notebook container which is not covered by other attributes.
 
@@ -797,11 +785,10 @@ def _hub_connect_port_default(self):
         or underscore-separated word (used by kubernetes python client, e.g. ``env_from``).
 
         """
-    )
+    ).tag(config=True)
 
     extra_pod_config = Dict(
-        None,
-        config=True,
+        default_value={},
         help="""
         Extra configuration (e.g. tolerations) for the pod which is not covered by other attributes.
 
@@ -816,11 +803,10 @@ def _hub_connect_port_default(self):
         The `key` could be either camelcase word (used by Kubernetes yaml, e.g. `dnsPolicy`)
         or underscore-separated word (used by kubernetes python client, e.g. `dns_policy`).
         """
-    )
+    ).tag(config=True)
 
     extra_containers = List(
-        None,
-        config=True,
+        default_value=[],
         help="""
         List of containers belonging to the pod which besides to the container generated for notebook server.
 
@@ -839,11 +825,122 @@ def _hub_connect_port_default(self):
             ]
 
         """
-    )
+    ).tag(config=True)
+
+    scheduler_name = Unicode(
+        default_value=None,
+        allow_none=True,
+        help="""
+        Set the pod's scheduler explicitly by name.
+        See the Kubernetes API documentation for additional details.
+        - https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.11/#podspec-v1-core
+        """
+    ).tag(config=True)
+
+    tolerations = List(
+        default_value=[],
+        help="""
+        List of tolerations that are to be assigned to the pod in order to be able to schedule the pod
+        on a node with the corresponding taints. See the official Kubernetes documentation for additional details
+        https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
+
+        Pass this field an array of "Toleration" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#nodeselectorterm-v1-core
+
+        Example:
+
+            [
+                {
+                    'key': 'key',
+                    'operator': 'Equal',
+                    'value': 'value',
+                    'effect': 'NoSchedule'
+                },
+                {
+                    'key': 'key',
+                    'operator': 'Exists',
+                    'effect': 'NoSchedule'
+                }
+            ]
+
+        """
+    ).tag(config=True)
+
+    node_affinity_preferred = List(
+        default_value=[],
+        help="""
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "PreferredSchedulingTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#preferredschedulingterm-v1-core
+        """
+    ).tag(config=True)
+    node_affinity_required = List(
+        default_value=[],
+        help="""
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "NodeSelectorTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#nodeselectorterm-v1-core
+        """
+    ).tag(config=True)
+    pod_affinity_preferred = List(
+        default_value=[],
+        help="""
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "WeightedPodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#weightedpodaffinityterm-v1-core
+        """
+    ).tag(config=True)
+    pod_affinity_required = List(
+        default_value=[],
+        help="""
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "PodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#podaffinityterm-v1-core
+        """
+    ).tag(config=True)
+    pod_anti_affinity_preferred = List(
+        default_value=[],
+        help="""
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "WeightedPodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#weightedpodaffinityterm-v1-core
+        """
+    ).tag(config=True)
+    pod_anti_affinity_required = List(
+        default_value=[],
+        help="""
+        Affinities describe where pods prefer or require to be scheduled, they
+        may prefer or require a node to have a certain label or be in proximity
+        / remoteness to another pod. To learn more visit
+        https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
+
+        Pass this field an array of "PodAffinityTerm" objects.*
+        * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/#podaffinityterm-v1-core
+        """
+    ).tag(config=True)
 
     extra_resource_guarantees = Dict(
-        {},
-        config=True,
+        default_value={},
         help="""
         The dictionary used to request arbitrary resources.
         Default is None and means no additional resources are requested.
@@ -851,11 +948,9 @@ def _hub_connect_port_default(self):
 
             {"nvidia.com/gpu": "3"}
         """
-    )
-
+    ).tag(config=True)
     extra_resource_limits = Dict(
-        {},
-        config=True,
+        default_value={},
         help="""
         The dictionary used to limit arbitrary resources.
         Default is None and means no additional resources are limited.
@@ -863,20 +958,19 @@ def _hub_connect_port_default(self):
 
             {"nvidia.com/gpu": "3"}
         """
-    )
+    ).tag(config=True)
 
     delete_stopped_pods = Bool(
-        True,
-        config=True,
+        default_value=True,
         help="""
         Whether to delete pods that have stopped themselves.
         Set to False to leave stopped pods in the completed state,
         allowing for easier debugging of why they may have stopped.
         """
-        )
+    ).tag(config=True)
 
     profile_form_template = Unicode(
-        """
+        default_value="""
         <script>
         // JupyterHub 0.8 applied form-control indisciminately to all form elements.
         // Can be removed once we stop supporting JupyterHub 0.8
@@ -907,7 +1001,6 @@ def _hub_connect_port_default(self):
         {% endfor %}
         </div>
         """,
-        config=True,
         help="""
         Jinja2 template for constructing profile list shown to user.
 
@@ -918,13 +1011,13 @@ def _hub_connect_port_default(self):
         posted, this form is expected to have an item with name `profile` and
         the value the index of the profile in `profile_list`.
         """
-    )
+    ).tag(config=True)
 
-    profile_list = Union([
+    profile_list = Union(
+        trait_types=[
             List(trait=Dict()),
             Callable()
         ],
-        config=True,
         help="""
         List of profiles to offer for selection by the user.
 
@@ -987,7 +1080,18 @@ def _hub_connect_port_default(self):
         across versions, so using this functionality might cause your JupyterHub
         or kubespawner upgrades to break.
         """
-    )
+    ).tag(config=True)
+
+    priority_class_name = Unicode(
+        default_value=None,
+        allow_none=True,
+        help="""
+        The priority class that the pods will use.
+
+        See https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption for
+        more information on how pod priority works.
+        """
+    ).tag(config=True)
 
     # deprecate redundant and inconsistent singleuser_ and user_ prefixes:
     _deprecated_traits = [
@@ -1111,7 +1215,7 @@ def _expand_user_properties(self, template):
             unescaped_username=self.user.name,
             legacy_escape_username=legacy_escaped_username,
             servername=servername
-            )
+        )
 
     def _expand_all(self, src):
         if isinstance(src, list):
@@ -1213,6 +1317,16 @@ def get_pod_manifest(self):
             extra_container_config=self.extra_container_config,
             extra_pod_config=self.extra_pod_config,
             extra_containers=self.extra_containers,
+            scheduler_name=self.scheduler_name,
+            tolerations=self.tolerations,
+            node_affinity_preferred=self.node_affinity_preferred,
+            node_affinity_required=self.node_affinity_required,
+            pod_affinity_preferred=self.pod_affinity_preferred,
+            pod_affinity_required=self.pod_affinity_required,
+            pod_anti_affinity_preferred=self.pod_anti_affinity_preferred,
+            pod_anti_affinity_required=self.pod_anti_affinity_required,
+            priority_class_name=self.priority_class_name,
+            logger=self.log,
         )
 
     def get_pvc_manifest(self):
@@ -1633,6 +1747,7 @@ def stop(self, now=False):
             self._start_watching_pods(replace=True)
             raise
 
+    @default('env_keep')
     def _env_keep_default(self):
         return []
 
@@ -1661,6 +1776,7 @@ def _render_options_form_dynamically(self, current_spawner):
         profile_list = yield gen.maybe_future(self.profile_list(current_spawner))
         return self._render_options_form(profile_list)
 
+    @default('options_form')
     def _options_form_default(self):
         '''
         Build the form template according to the `profile_list` setting.
diff --git a/kubespawner/utils.py b/kubespawner/utils.py
index 52053df9..25a5aeb7 100644
--- a/kubespawner/utils.py
+++ b/kubespawner/utils.py
@@ -2,7 +2,7 @@
 Misc. general utility functions, not tied to Kubespawner directly
 """
 import hashlib
-
+import copy
 
 def generate_hashed_slug(slug, limit=63, hash_length=6):
     """
@@ -27,3 +27,112 @@ def generate_hashed_slug(slug, limit=63, hash_length=6):
         prefix=slug[:limit - hash_length - 1],
         hash=slug_hash[:hash_length],
     ).lower()
+
+
+def update_k8s_model(target, source, logger=None, origin=None):
+    """
+    Takes a model instance such as V1PodSpec() and updates it with another
+    model representation. The origin parameter could be "extra_pod_config" for
+    example.
+    """
+    model = type(target)
+    if not hasattr(target, 'attribute_map'):
+        raise AttributeError("Attribute 'target' ({}) must be an object (such as 'V1PodSpec') with an attribute 'attribute_map'.".format(model.__name__))
+    if not isinstance(source, model) and not isinstance(source, dict):
+        raise AttributeError("Attribute 'source' ({}) must be an object of the same type as 'target' ({}) or a 'dict'.".format(type(source).__name__, model.__name__))
+
+    source_dict = _get_k8s_model_dict(model, source)
+    for key, value in source_dict.items():
+        if key not in target.attribute_map:
+            raise ValueError("The attribute 'source' ({}) contained '{}' not modeled by '{}'.".format(type(source).__name__, key, model.__name__))
+        if getattr(target, key):
+            if logger and origin:
+                logger.warning("Overriding KubeSpawner.{}'s value '{getattr(target,key)}' with '{}'.".format(origin, value))
+        setattr(target, key, value)
+
+    return target
+
+def get_k8s_model(model, model_dict):
+    """
+    Returns a model object from an model instance or represantative dictionary.
+    """
+    model_dict = copy.deepcopy(model_dict)
+
+    if isinstance(model_dict, model):
+        return model_dict
+    elif isinstance(model_dict, dict):
+        _map_dict_keys_to_model_attributes(model, model_dict)
+        return model(**model_dict)
+    else:
+        raise AttributeError("Expected object of type 'dict' (or '{}') but got '{}'.".format(model.__type__.__name__, model_dict.__type__.__name__))
+
+def _get_k8s_model_dict(model, obj):
+    """
+    Returns a model of dictionary kind
+    """
+    obj = copy.deepcopy(obj)
+
+    if isinstance(obj, model):
+        return obj.to_dict()
+    elif isinstance(obj, dict):
+        return _map_dict_keys_to_model_attributes(model, obj)
+    else:
+        raise AttributeError("Expected object of type '{}' (or 'dict') but got '{}'.".format(model.__type__.__name__, obj.__type__.__name__))
+
+def _map_dict_keys_to_model_attributes(model, model_dict):
+    """
+    Maps a dict's keys to the provided models attributes using its attribute_map
+    attribute. This is (always?) the same as converting camelCase to snake_case.
+    Note that the function will not influence nested object's keys.
+    """
+
+    for key in list(model_dict.keys()):
+        model_dict[_get_k8s_model_attribute(model, key)] = model_dict.pop(key)
+
+    return model_dict
+
+def _get_k8s_model_attribute(model, field_name):
+    """
+    Takes an kubernetes resource field name such as "serviceAccount" and returns
+    its associated attribute name "service_account" used by the provided
+    kubernetes.client.models object representing the resource.
+
+    Example of V1PodSpec's attribute_map:
+    {
+        'active_deadline_seconds': 'activeDeadlineSeconds',
+        'affinity': 'affinity',
+        'automount_service_account_token': 'automountServiceAccountToken',
+        'containers': 'containers',
+        'dns_policy': 'dnsPolicy',
+        'host_aliases': 'hostAliases',
+        'host_ipc': 'hostIPC',
+        'host_network': 'hostNetwork',
+        'host_pid': 'hostPID',
+        'hostname': 'hostname',
+        'image_pull_secrets': 'imagePullSecrets',
+        'init_containers': 'initContainers',
+        'node_name': 'nodeName',
+        'node_selector': 'nodeSelector',
+        'priority': 'priority',
+        'priority_class_name': 'priorityClassName',
+        'restart_policy': 'restartPolicy',
+        'scheduler_name': 'schedulerName',
+        'security_context': 'securityContext',
+        'service_account': 'serviceAccount',
+        'service_account_name': 'serviceAccountName',
+        'subdomain': 'subdomain',
+        'termination_grace_period_seconds': 'terminationGracePeriodSeconds',
+        'tolerations': 'tolerations',
+        'volumes': 'volumes'
+    }
+    """
+    # if we get "service_account", return
+    if field_name in model.attribute_map:
+        return field_name
+
+    # if we get "serviceAccount", then return "service_account"
+    for key, value in model.attribute_map.items():
+        if value == field_name:
+            return key
+    else:
+        raise ValueError("'{}' does not model '{}'".format(model.__name__, field_name))
diff --git a/setup.py b/setup.py
index b276c63b..273ad1e9 100644
--- a/setup.py
+++ b/setup.py
@@ -10,16 +10,16 @@
 
 setup(
     name='jupyterhub-kubespawner',
-    version='0.8.1',
+    version='0.9.1',
     install_requires=[
-        'jupyterhub>=0.8',
+        'jupyterhub>=0.9',
         'pyYAML',
         'kubernetes==6.*',
         'escapism',
         'jinja2',
         'async_generator>=1.8',
     ],
-    python_requires     = ">=3.5",
+    python_requires='>=3.5',
     setup_requires=['pytest-runner'],
     tests_require=['pytest'],
     description='JupyterHub Spawner targeting Kubernetes',
diff --git a/tests/test_objects.py b/tests/test_objects.py
index 27589950..773216d1 100644
--- a/tests/test_objects.py
+++ b/tests/test_objects.py
@@ -4,7 +4,6 @@
 from kubespawner.objects import make_pod, make_pvc
 from kubernetes.client import ApiClient
 
-
 api_client = ApiClient()
 
 def test_make_simplest_pod():
@@ -360,7 +359,7 @@ def test_run_privileged_container():
                     "ports": [{
                         "name": "notebook-port",
                         "containerPort": 8888
-                    }],                    
+                    }],
                     "resources": {
                         "limits": {},
                         "requests": {}
@@ -919,7 +918,7 @@ def test_make_resources_all():
         }
     }
 
-    
+
 def test_make_pod_with_service_account():
     """
     Test specification of the simplest possible pod specification with non-default service account
@@ -963,3 +962,514 @@ def test_make_pod_with_service_account():
         "kind": "Pod",
         "apiVersion": "v1"
     }
+
+
+def test_make_pod_with_scheduler_name():
+    """
+    Test specification of the simplest possible pod specification with non-default scheduler name
+    """
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        scheduler_name='my-custom-scheduler'
+    )) == {
+        "metadata": {
+            "name": "test",
+            "annotations": {},
+            "labels": {},
+        },
+        "spec": {
+            "securityContext": {},
+            'automountServiceAccountToken': False,
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            'volumes': [],
+            'schedulerName': 'my-custom-scheduler',
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+
+def test_make_pod_with_tolerations():
+    """
+    Test specification of the simplest possible pod specification with non-empty tolerations
+    """
+    tolerations = [
+        {
+            'key': 'hub.jupyter.org/dedicated',
+            'operator': 'Equal',
+            'value': 'user',
+            'effect': 'NoSchedule'
+        },
+        {
+            'key': 'key',
+            'operator': 'Exists',
+            'effect': 'NoSchedule'
+        }
+    ]
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        tolerations=tolerations
+    )) == {
+        "metadata": {
+            "name": "test",
+            "labels": {},
+            "annotations": {}
+        },
+        "spec": {
+            "automountServiceAccountToken": False,
+            "securityContext": {},
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            'volumes': [],
+            'tolerations': tolerations
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+def test_make_pod_with_node_affinity_preferred():
+    """
+    Test specification of the simplest possible pod specification with non-empty node_affinity_preferred
+    """
+    node_affinity_preferred = [{
+        "weight": 1,
+        "preference": {
+            "matchExpressions": [{
+                "key": "hub.jupyter.org/node-purpose",
+                "operator": "In",
+                "values": ["user"],
+            }],
+        }
+    }]
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        node_affinity_preferred=node_affinity_preferred
+    )) == {
+        "metadata": {
+            "name": "test",
+            "labels": {},
+            "annotations": {}
+        },
+        "spec": {
+            "automountServiceAccountToken": False,
+            "securityContext": {},
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            "volumes": [],
+            "affinity": {
+                "nodeAffinity": {
+                    "preferredDuringSchedulingIgnoredDuringExecution": node_affinity_preferred
+                }
+            }
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+def test_make_pod_with_node_affinity_required():
+    """
+    Test specification of the simplest possible pod specification with non-empty node_affinity_required
+    """
+    node_affinity_required = [{
+        "matchExpressions": [{
+            "key": "hub.jupyter.org/node-purpose",
+            "operator": "In",
+            "values": ["user"],
+        }]
+    }]
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        node_affinity_required=node_affinity_required
+    )) == {
+        "metadata": {
+            "name": "test",
+            "labels": {},
+            "annotations": {}
+        },
+        "spec": {
+            "automountServiceAccountToken": False,
+            "securityContext": {},
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            "volumes": [],
+            "affinity": {
+                "nodeAffinity": {
+                    "requiredDuringSchedulingIgnoredDuringExecution": {
+                        "nodeSelectorTerms": node_affinity_required
+                    }
+                }
+            }
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+def test_make_pod_with_pod_affinity_preferred():
+    """
+    Test specification of the simplest possible pod specification with non-empty pod_affinity_preferred
+    """
+    pod_affinity_preferred = [{
+        "weight": 100,
+        "podAffinityTerm": {
+            "labelSelector": {
+                "matchExpressions": [{
+                    "key": "hub.jupyter.org/pod-kind",
+                    "operator": "In",
+                    "values": ["user"],
+                }]
+            },
+            "topologyKey": "kubernetes.io/hostname"
+        }
+    }]
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        pod_affinity_preferred=pod_affinity_preferred
+    )) == {
+        "metadata": {
+            "name": "test",
+            "labels": {},
+            "annotations": {}
+        },
+        "spec": {
+            "automountServiceAccountToken": False,
+            "securityContext": {},
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            "volumes": [],
+            "affinity": {
+                "podAffinity": {
+                    "preferredDuringSchedulingIgnoredDuringExecution": pod_affinity_preferred
+                }
+            }
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+
+def test_make_pod_with_pod_affinity_required():
+    """
+    Test specification of the simplest possible pod specification with non-empty pod_affinity_required
+    """
+    pod_affinity_required = [{
+        "labelSelector": {
+            "matchExpressions": [{
+                "key": "security",
+                "operator": "In",
+                "values": ["S1"],
+            }]
+        },
+        "topologyKey": "failure-domain.beta.kubernetes.io/zone"
+    }]
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        pod_affinity_required=pod_affinity_required
+    )) == {
+        "metadata": {
+            "name": "test",
+            "labels": {},
+            "annotations": {}
+        },
+        "spec": {
+            "automountServiceAccountToken": False,
+            "securityContext": {},
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            "volumes": [],
+            "affinity": {
+                "podAffinity": {
+                    "requiredDuringSchedulingIgnoredDuringExecution": pod_affinity_required
+                }
+            }
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+def test_make_pod_with_pod_anti_affinity_preferred():
+    """
+    Test specification of the simplest possible pod specification with non-empty pod_anti_affinity_preferred
+    """
+    pod_anti_affinity_preferred = [{
+        "weight": 100,
+        "podAffinityTerm": {
+            "labelSelector": {
+                "matchExpressions": [{
+                    "key": "hub.jupyter.org/pod-kind",
+                    "operator": "In",
+                    "values": ["user"],
+                }]
+            },
+            "topologyKey": "kubernetes.io/hostname"
+        }
+    }]
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        pod_anti_affinity_preferred=pod_anti_affinity_preferred
+    )) == {
+        "metadata": {
+            "name": "test",
+            "labels": {},
+            "annotations": {}
+        },
+        "spec": {
+            "automountServiceAccountToken": False,
+            "securityContext": {},
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            "volumes": [],
+            "affinity": {
+                "podAntiAffinity": {
+                    "preferredDuringSchedulingIgnoredDuringExecution": pod_anti_affinity_preferred
+                }
+            }
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+
+def test_make_pod_with_pod_anti_affinity_required():
+    """
+    Test specification of the simplest possible pod specification with non-empty pod_anti_affinity_required
+    """
+    pod_anti_affinity_required = [{
+        "labelSelector": {
+            "matchExpressions": [{
+                "key": "security",
+                "operator": "In",
+                "values": ["S1"],
+            }]
+        },
+        "topologyKey": "failure-domain.beta.kubernetes.io/zone"
+    }]
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        pod_anti_affinity_required=pod_anti_affinity_required
+    )) == {
+        "metadata": {
+            "name": "test",
+            "labels": {},
+            "annotations": {}
+        },
+        "spec": {
+            "automountServiceAccountToken": False,
+            "securityContext": {},
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            "volumes": [],
+            "affinity": {
+                "podAntiAffinity": {
+                    "requiredDuringSchedulingIgnoredDuringExecution": pod_anti_affinity_required
+                }
+            }
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
+
+def test_make_pod_with_priority_class_name():
+    """
+    Test specification of the simplest possible pod specification with non-default priorityClassName set
+    """
+    assert api_client.sanitize_for_serialization(make_pod(
+        name='test',
+        image_spec='jupyter/singleuser:latest',
+        cmd=['jupyterhub-singleuser'],
+        port=8888,
+        image_pull_policy='IfNotPresent',
+        priority_class_name='my-custom-priority-class'
+    )) == {
+        "metadata": {
+            "name": "test",
+            "annotations": {},
+            "labels": {},
+        },
+        "spec": {
+            "securityContext": {},
+            'automountServiceAccountToken': False,
+            "containers": [
+                {
+                    "env": [],
+                    "name": "notebook",
+                    "image": "jupyter/singleuser:latest",
+                    "imagePullPolicy": "IfNotPresent",
+                    "args": ["jupyterhub-singleuser"],
+                    "ports": [{
+                        "name": "notebook-port",
+                        "containerPort": 8888
+                    }],
+                    'volumeMounts': [],
+                    "resources": {
+                        "limits": {},
+                        "requests": {}
+                    }
+                }
+            ],
+            'volumes': [],
+            'priorityClassName': 'my-custom-priority-class',
+        },
+        "kind": "Pod",
+        "apiVersion": "v1"
+    }
diff --git a/tests/test_spawner.py b/tests/test_spawner.py
index 1f6f0ea2..e2dd3276 100644
--- a/tests/test_spawner.py
+++ b/tests/test_spawner.py
@@ -1,22 +1,30 @@
 from traitlets.config import Config
+from asyncio import get_event_loop
 from kubespawner import KubeSpawner
+from kubernetes.client.models import (
+    V1SecurityContext, V1Container, V1Capabilities, V1Pod
+)
+
+def sync_wait(future):
+    loop = get_event_loop()
+    loop.run_until_complete(future)
+    return future.result()
 
 
 def test_deprecated_config():
     """Deprecated config is handled correctly"""
-    cfg = Config()
-    ks_cfg = cfg.KubeSpawner
+    c = Config()
     # both set, non-deprecated wins
-    ks_cfg.singleuser_fs_gid = 5
-    ks_cfg.fs_gid = 10
+    c.KubeSpawner.singleuser_fs_gid = 5
+    c.KubeSpawner.fs_gid = 10
     # only deprecated set, should still work
-    ks_cfg.singleuser_extra_pod_config = extra_pod_config = {"key": "value"}
-    spawner = KubeSpawner(config=cfg, _mock=True)
+    c.KubeSpawner.singleuser_extra_pod_config = extra_pod_config = {"key": "value"}
+    spawner = KubeSpawner(config=c, _mock=True)
     assert spawner.fs_gid == 10
     assert spawner.extra_pod_config == extra_pod_config
     # deprecated access gets the right values, too
     assert spawner.singleuser_fs_gid == spawner.fs_gid
-    assert spawner.singleuser_extra_pod_config == spawner.singleuser_extra_pod_config
+    assert spawner.singleuser_extra_pod_config == spawner.extra_pod_config
 
 
 def test_deprecated_runtime_access():
@@ -28,3 +36,39 @@ def test_deprecated_runtime_access():
     spawner.uid = 20
     assert spawner.uid == 20
     assert spawner.singleuser_uid == 20
+
+
+def test_get_pod_manifest_tolerates_mixed_input():
+    """
+    Test that the get_pod_manifest function can handle a either a dictionary or
+    an object both representing V1Container objects and that the function
+    returns a V1Pod object containing V1Container objects.
+    """
+    c = Config()
+
+    dict_model = {
+        'name': 'mock_name_1',
+        'image': 'mock_image_1',
+        'command': ['mock_command_1']
+    }
+    object_model = V1Container(
+        name="mock_name_2",
+        image="mock_image_2",
+        command=['mock_command_2'],
+        security_context=V1SecurityContext(
+            privileged=True,
+            run_as_user=0,
+            capabilities=V1Capabilities(add=['NET_ADMIN'])
+        )
+    )
+    c.KubeSpawner.init_containers = [dict_model, object_model]
+
+    spawner = KubeSpawner(config=c, _mock=True)
+
+    # this test ensures the following line doesn't raise an error
+    manifest = sync_wait(spawner.get_pod_manifest())
+
+    # and tests the return value's types
+    assert isinstance(manifest, V1Pod)
+    assert isinstance(manifest.spec.init_containers[0], V1Container)
+    assert isinstance(manifest.spec.init_containers[1], V1Container)
diff --git a/tests/test_utils.py b/tests/test_utils.py
new file mode 100644
index 00000000..dc627b1f
--- /dev/null
+++ b/tests/test_utils.py
@@ -0,0 +1,54 @@
+import copy
+from kubespawner.utils import get_k8s_model, update_k8s_model, _get_k8s_model_attribute
+from kubernetes.client.models import (
+    V1PodSpec, V1SecurityContext, V1Container, V1Capabilities, V1Lifecycle
+)
+
+def test__get_k8s_model_attribute():
+    """Verifies fundamental behavior"""
+    assert _get_k8s_model_attribute(V1PodSpec, "service_account") == "service_account"
+    assert _get_k8s_model_attribute(V1PodSpec, "serviceAccount") == "service_account"
+
+def test_update_k8s_model():
+    """Updates an attributes using update_k8s_model and manually and verifies
+    output matches."""
+    manually_updated_target = V1Container(
+        name="mock_name",
+        image="mock_image",
+        command=['iptables'],
+        security_context=V1SecurityContext(
+            privileged=True,
+            run_as_user=0,
+            capabilities=V1Capabilities(add=['NET_ADMIN'])
+        )
+    )
+    target = copy.deepcopy(manually_updated_target)
+    source = {"name": "new_mock_name"}
+    update_k8s_model(target, source)
+
+    manually_updated_target.name = "new_mock_name"
+    
+    assert target == manually_updated_target
+
+def test_get_k8s_model():
+    """Passing an model type and a dictionary to model it."""
+    v1_lifecycle = get_k8s_model(
+        V1Lifecycle,
+        {
+            'preStop': {
+                'exec': {
+                    'command': ['/bin/sh', 'test']
+                }
+            }
+        },
+    ) 
+    
+    assert isinstance(v1_lifecycle, V1Lifecycle)
+    assert v1_lifecycle.to_dict() == {
+        'post_start': None,
+        'pre_stop': {
+            'exec': {
+                'command': ['/bin/sh', 'test']
+            }
+        },
+    }
diff --git a/tox.ini b/tox.ini
index 307ae3d2..423408a7 100644
--- a/tox.ini
+++ b/tox.ini
@@ -2,7 +2,7 @@
 minversion = 1.6
 skipsdist = True
 
-envlist = py34,py35,py36
+envlist = py35,py36
 
 [flake8]
 max-line-length = 100