Uploading work on refactor

At this point, all components can build their skeletons. Next steps are to get components building their rigs.

15 files changed, 3036 insertions, 0 deletions

diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/__init__.py
diff --git a/tests/test_arm_component.py b/tests/test_arm_component.py
new file mode 100644
index 0000000..2e432d8
--- /dev/null
+++ b/tests/test_arm_component.py
@@ -0,0 +1,288 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.arm as arm
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Arm_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for hinge module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_arm_inst(self, prefix):
+
+        root.Root()
+        arm_inst = arm.Arm(prefix=prefix)
+        arm_inst.parent = "root"
+        return arm_inst
+
+    def test_create_arm(self):
+
+        self._create_asset()
+        arm_inst = self._create_arm_inst("l")
+        self.assertEquals(len(arm_inst.joint_mover.get_created_joints()), 3)
+
+        arm_inst.num_upperarm_twists = 2
+        self.assertEquals(len(arm_inst.joint_mover.get_created_joints()), 5)
+
+        arm_inst.num_lowerarm_twists = 2
+        self.assertEquals(len(arm_inst.joint_mover.get_created_joints()), 7)
+
+    def test_delete_arm(self):
+
+        self._create_asset()
+        root.Root()
+        l_arm_inst = arm.Arm(prefix="l")
+        r_arm_inst = arm.Arm(prefix="r", side="right")
+        l_arm_inst.parent = "root"
+        r_arm_inst.parent = "l_upperarm"
+
+        component_containers = l_arm_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        l_arm_inst.delete()
+        self.assertFalse(cmds.objExists("l_arm_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(r_arm_inst.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        root.Root()
+        l_arm_inst = arm.Arm(prefix="l")
+        l_arm_inst.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("l_arm_lowerarm_mover_offset.translateY", 30)
+
+        pre_offset_position = format_position(cmds.xform("l_arm_lowerarm_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("l_arm_lowerarm_mover", q=True, ws=True, t=True))
+        pre_hand_position = format_position(cmds.xform("l_arm_hand_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        l_arm_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("l_arm_lowerarm_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("l_arm_lowerarm_mover", q=True, ws=True, t=True))
+        post_hand_position = format_position(cmds.xform("l_arm_hand_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_hand_position, post_hand_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        root.Root()
+        l_arm_inst = arm.Arm(prefix="l")
+        l_arm_inst.parent = "root"
+
+        pre_position = format_position(cmds.xform("l_arm_upperarm_mover", q=True, ws=True, t=True))
+        l_arm_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(l_arm_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("l_arm_upperarm_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        l_arm_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("l_arm_upperarm_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        root.Root()
+        l_arm_inst = arm.Arm(prefix="l")
+        l_arm_inst.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(l_arm_inst.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(l_arm_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee out and then test if the thigh offset orientations have changed.
+        original_orientation = cmds.xform("l_arm_upperarm_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_arm_lowerarm_mover_offset.translateY", 30)
+        new_orientation = cmds.xform("l_arm_upperarm_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        # turn off aim mode and double check attrs once again
+        l_arm_inst.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(l_arm_inst.network_node.isAiming.get(), False)
+        self.assertEquals(len(l_arm_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee again and test if the thigh offset orientations did not change.
+        original_orientation = cmds.xform("l_arm_upperarm_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_arm_lowerarm_mover_offset.translateY", 0)
+        new_orientation = cmds.xform("l_arm_upperarm_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_right_side(self):
+
+        self._create_asset()
+        root.Root()
+        l_arm_inst = arm.Arm(prefix="l")
+        r_arm_inst = arm.Arm(prefix="r", side="right")
+        test_arm_inst = arm.Arm(prefix="test")
+
+        l_joints = sorted(l_arm_inst.joint_mover.get_driven_joints())
+        r_joints = sorted(r_arm_inst.joint_mover.get_driven_joints())
+        test_joints = sorted(test_arm_inst.joint_mover.get_driven_joints())
+
+        for i in range(len(l_joints)):
+
+            l_joint = cmds.xform(l_joints[i].nodeName(), q=True, ws=True, ro=True)
+            r_joint = cmds.xform(r_joints[i].nodeName(), q=True, ws=True, ro=True)
+            test_joint = cmds.xform(test_joints[i].nodeName(), q=True, ws=True, ro=True)
+
+            self.assertNotEquals(l_joint, r_joint)
+            self.assertEquals(l_joint, test_joint)
+
+    def test_set_side(self):
+
+        self._create_asset()
+        root.Root()
+        l_arm_inst = arm.Arm(prefix="l")
+        l_arm_inst.parent = "root"
+        l_arm_inst.set_side("right")
+        l_arm_inst.set_side("left")
+
+        l_arm_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        root.Root()
+        arm_inst = arm.Arm(prefix="l", side="right")
+        arm_inst.parent = "root"
+
+        cmds.setAttr("l_arm_upperarm_mover.translateZ", -65)
+        cmds.setAttr("l_arm_upperarm_mover.rotateX", -3)
+        cmds.setAttr("l_arm_upperarm_mover.rotateY", -8)
+        cmds.setAttr("l_arm_upperarm_mover.rotateZ", 42)
+        cmds.setAttr("l_arm_upperarm_mover.scaleX", .319)
+        cmds.setAttr("l_arm_upperarm_mover.scaleY", .319)
+        cmds.setAttr("l_arm_upperarm_mover.scaleZ", .319)
+
+        cmds.setAttr("l_arm_lowerarm_mover.rotateX", 1.5)
+        cmds.setAttr("l_arm_lowerarm_mover.rotateY", -27)
+        cmds.setAttr("l_arm_lowerarm_mover.rotateZ", -45)
+
+        duplicate_inst = arm_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("l_arm_01_upperarm_mover.tz"), cmds.getAttr("l_arm_upperarm_mover.tz"))
+        self.assertEquals(cmds.getAttr("l_arm_01_upperarm_mover.rx"), cmds.getAttr("l_arm_upperarm_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_arm_01_upperarm_mover.ry"), cmds.getAttr("l_arm_upperarm_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_arm_01_upperarm_mover.rz"), cmds.getAttr("l_arm_upperarm_mover.rz"))
+        self.assertEquals(cmds.getAttr("l_arm_01_upperarm_mover.sx"), cmds.getAttr("l_arm_upperarm_mover.sx"))
+        self.assertEquals(cmds.getAttr("l_arm_01_upperarm_mover.sy"), cmds.getAttr("l_arm_upperarm_mover.sy"))
+        self.assertEquals(cmds.getAttr("l_arm_01_upperarm_mover.sz"), cmds.getAttr("l_arm_upperarm_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("l_arm_01_lowerarm_mover.rx"), cmds.getAttr("l_arm_lowerarm_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_arm_01_lowerarm_mover.ry"), cmds.getAttr("l_arm_lowerarm_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_arm_01_lowerarm_mover.rz"), cmds.getAttr("l_arm_lowerarm_mover.rz"))
+        dupe2 = arm_inst.duplicate()
+        dupe3 = arm_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        root.Root()
+        left_arm_inst = arm.Arm(prefix="l")
+        left_arm_inst.parent = "root"
+
+        cmds.setAttr("l_arm_upperarm_mover.translateX", 30)
+        cmds.setAttr("l_arm_lowerarm_mover.rotateZ", -40)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_arm_inst = left_arm_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = left_arm_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_arm_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_arm_upperarm_mover.translateX"), -30)
+        self.assertEquals(cmds.getAttr("r_arm_lowerarm_mover.rotateZ"), -40)
+        self.assertEquals(cmds.getAttr("r_arm_upperarm_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator(name=mover+"_loc")[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        root.Root()
+        left_arm_inst = arm.Arm(prefix="l")
+        left_arm_inst.parent = "root"
+        right_arm_inst = left_arm_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_arm_inst.delete()
+
+        self.assertEquals(right_arm_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_arm_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        root.Root()
+        left_arm_inst = arm.Arm(prefix="l")
+        left_arm_inst.parent = "root"
+        left_arm_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("l_arm_upperarm_mover.translateZ", -20)
+        cmds.setAttr("l_arm_upperarm_mover.rotateX", 40)
+
+        left_arm_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_arm_upperarm_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_arm_upperarm_mover.rotateX"), 40)
+
+    def test_invalid_property_value(self):
+
+        self._create_asset()
+        root.Root()
+        l_arm_inst = arm.Arm(prefix="l")
+
+        with self.assertRaises(RuntimeError):
+            l_arm_inst.num_lowerarm_twists = 5.5
+
+        with self.assertRaises(RuntimeError):
+            l_arm_inst.num_upperarm_twists = 4
+
+        with self.assertRaises(RuntimeError):
+            l_arm_inst.num_upperarm_twists = "test"
+
+        with self.assertRaises(RuntimeError):
+            l_arm_inst.num_upperarm_twists = "2.5"
diff --git a/tests/test_basic_components.py b/tests/test_basic_components.py
new file mode 100644
index 0000000..25a736b
--- /dev/null
+++ b/tests/test_basic_components.py
@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+"""
+This module contains a class for running tests on components. These tests include adding them to a scene, renaming,
+reparenting, etc.
+"""
+
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.biped_leg as leg
+import artv2.utilities.component_utilities as component_utils
+import artv2.components.hinge as hinge
+import artv2.utilities.rigging_utilities as rigging_utils
+
+
+class Basic_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for rig module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def test_create_component_twice(self):
+
+        self._create_asset()
+
+        # twice of the same instance
+        root_inst = root.Root()
+        with self.assertRaises(RuntimeError):
+            root_inst._create_component("", "")
+
+        # and twice of the same class
+        leg_inst1 = leg.BipedLeg("l")
+        with self.assertRaises(RuntimeError):
+            leg_inst2 = leg.BipedLeg("l")
+
+        # however, this should pass
+        leg_inst2 = leg.BipedLeg("r")
+        self.assertNotEquals(leg_inst1, leg_inst2)
+
+    def test_create_building_components(self):
+        self._create_asset()
+
+        root_inst = root.Root()
+        self.assertEquals(root_inst._unique_name, "master")
+
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        self.assertEquals(l_leg_inst._unique_name, "l_leg")
+
+        mover_name = component_utils.find_associated_mover_from_joint("l_thigh")
+        self.assertEquals(mover_name, "l_leg_thigh_mover")
+
+        mover_name = component_utils.find_associated_mover_from_joint("l_thigh_twist_01")
+        self.assertEquals(mover_name, "l_leg_thigh_twist_01_mover_offset")
+
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 5)
+
+    def test_parenting(self):
+
+        self._create_asset()
+
+        root_inst = root.Root()
+        self.assertEquals(root_inst._unique_name, "master")
+
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        l_leg_inst.parent = "root"
+        self.assertEquals(l_leg_inst._unique_name, "l_leg")
+
+        leg_inst = leg.BipedLeg(prefix="test")
+        leg_inst.parent = "root"
+        network_node = leg_inst.network_node
+        self.assertEquals(leg_inst._unique_name, "test_leg")
+
+        # try adding thigh twists
+        l_leg_inst.num_thigh_twists = 2
+        l_leg_inst.num_calf_twists = 2
+
+        cmds.setAttr("test_leg_thigh_mover.tz", -40)
+        leg_inst.parent = "l_thigh_twist_02"
+
+        # then remove twists, which should result in the leg_inst having its parent set to root
+        l_leg_inst.num_thigh_twists = 1
+        l_leg_inst.num_calf_twists = 1
+
+        inst = leg.BipedLeg(network_node=network_node)
+        self.assertEquals(inst.parent, "root")
+
+    def test_renaming_component_dependencies(self):
+
+        self._create_asset()
+        root_inst = root.Root()
+        self.assertEquals(root_inst._unique_name, "master")
+
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        l_leg_inst.parent = "root"
+        l_leg_inst.num_thigh_twists = 2
+
+        r_leg_inst = leg.BipedLeg(prefix="r")
+        r_leg_inst.parent = "l_thigh_twist_02"
+        cmds.setAttr("r_leg_thigh_mover.tz", -40)
+
+        r_leg_inst.suffix = "r"
+        l_leg_inst.prefix = None
+        l_leg_inst.suffix = "l"
+
+        self.assertEquals(cmds.getAttr(r_leg_inst.network_node + ".parentComponentBone"), "thigh_twist_02_l")
+
+    def test_invalid_names(self):
+
+        self._create_asset()
+        root_inst = root.Root()
+        self.assertEquals(root_inst._unique_name, "master")
+
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        l_leg_inst.parent = "root"
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.prefix = "123abcABC"
+
+        l_leg_inst.prefix = "aBc123"
+        mover_grp = cmds.listConnections(l_leg_inst.network_node + ".mover_grp")[0]
+        self.assertEquals(mover_grp, "aBc123_leg_thigh_mover_grp")
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.prefix = "l-side"
+
+    def test_deleting_locked_nodes(self):
+
+        self._create_asset()
+        root_inst = root.Root()
+        self.assertEquals(root_inst._unique_name, "master")
+
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        l_leg_inst.parent = "root"
+
+        mover_grp = cmds.listConnections(l_leg_inst.network_node + ".mover_grp")[0]
+        cmds.select(mover_grp, hi=True)
+
+        selection = cmds.ls(sl=True)
+        num_nodes = len(selection)
+
+        with self.assertRaises(RuntimeError):
+            cmds.delete()
+
+        selection = cmds.ls(sl=True)
+        new_num_nodes = len(selection)
+
+        self.assertEquals(num_nodes, new_num_nodes)
+
+        # change number of thigh twists which should unlock movers
+        l_leg_inst.num_thigh_twists = 2
+
+        # then try deleting again, which should still be okay as long as the nodes are re-locked.
+        cmds.select(mover_grp, hi=True)
+
+        selection = cmds.ls(sl=True)
+        num_nodes = len(selection)
+
+        with self.assertRaises(RuntimeError):
+            cmds.delete()
+
+        selection = cmds.ls(sl=True)
+        new_num_nodes = len(selection)
+
+        self.assertEquals(num_nodes, new_num_nodes)
+
+    def test_accessing_instances(self):
+
+        self._create_asset()
+
+        root_inst = root.Root()
+        self.assertEquals(root_inst._unique_name, "master")
+
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        network_node = l_leg_inst.network_node
+
+        access_inst = leg.BipedLeg(network_node=network_node)
+
+        self.assertEquals(l_leg_inst.prefix, access_inst.prefix)
+        self.assertEquals(l_leg_inst.network_node, access_inst.network_node)
+        self.assertEquals(access_inst.prefix, "l_")
+
+    def test_renaming_with_conflicts(self):
+
+        self._create_asset()
+
+        root_inst = root.Root()
+        self.assertEquals(root_inst._unique_name, "master")
+
+        l_leg_inst = leg.BipedLeg()
+        l_leg_inst.prefix = "l"
+
+        r_leg_inst = leg.BipedLeg()
+        with self.assertRaises(RuntimeError):
+            r_leg_inst.prefix = "l"
+        r_leg_inst.prefix = "r"
+
+        with self.assertRaises(RuntimeError):
+            leg.BipedLeg(prefix="r")
+
+        l_leg_inst.suffix = "test"
+        r_leg_inst.suffix = "test"
+
+        with self.assertRaises(RuntimeError):
+            r_leg_inst.prefix = "l"
+
+        with self.assertRaises(RuntimeError):
+            leg.BipedLeg(prefix="l", suffix="test")
+
+        access_inst = leg.BipedLeg(network_node="l_leg_test_metadata")
+        self.assertEquals(access_inst.prefix, "l_")
+        self.assertEquals(access_inst.suffix, "_test")
+
+    def test_delete_root(self):
+
+        self._create_asset()
+        root_inst = root.Root()
+
+        leg_inst = leg.BipedLeg(prefix="l")
+        leg_inst.parent = "root"
+
+        with self.assertRaises(RuntimeError):
+            root_inst.delete()
+
+        leg_inst.delete()
+        root_inst.delete()
+
+        self.assertEquals(cmds.objExists("master_metadata"), False)
+
+    def test_rename_joint(self):
+
+        self._create_asset()
+        root.Root()
+
+        leg_inst = leg.BipedLeg(prefix="l")
+        leg_inst.parent = "root"
+
+        hinge_inst = hinge.Hinge(prefix="l")
+        hinge_inst.parent = "l_foot"
+
+        data = component_utils.get_joint_labels(leg_inst.network_node)
+        offset_mover = data.get("foot")[2]
+        leg_inst.rename_joint("l_ankle", "l_foot", offset_mover)
+
+        self.assertEquals(offset_mover.created_joint.get(), "l_ankle")
+        self.assertEquals(offset_mover.connected_joint.connections()[0].nodeName(), "l_leg_foot")
+        self.assertEquals(hinge_inst.parent, "l_ankle")
+
+        data = component_utils.get_joint_labels(hinge_inst.network_node)
+        offset_mover = data.get("middle")[2]
+
+        with self.assertRaises(RuntimeError):
+            hinge_inst.rename_joint("l_ankle", "l_middle", offset_mover)
+
+    def test_build_skeleton(self):
+
+        self._create_asset()
+        root.Root()
+
+        leg_inst = leg.BipedLeg(prefix="l")
+        leg_inst.parent = "root"
+
+        hinge_inst = hinge.Hinge(prefix="l")
+        hinge_inst.parent = "l_foot"
+
+        data = component_utils.get_joint_labels(leg_inst.network_node)
+        offset_mover = data.get("foot")[2]
+        leg_inst.rename_joint("l_ankle", "l_foot", offset_mover)
+
+        rigging_utils.build_skeleton()
+
+        self.assertEquals(cmds.objExists("l_thigh"), True)
+        self.assertEquals(cmds.objExists("l_calf"), True)
+        self.assertEquals(cmds.objExists("l_ankle"), True)
+        self.assertEquals(cmds.objExists("l_ball"), True)
+        self.assertEquals(cmds.objExists("root"), True)
+
+
+
+
+
+
+
+
diff --git a/tests/test_biped_leg_component.py b/tests/test_biped_leg_component.py
new file mode 100644
index 0000000..44140c0
--- /dev/null
+++ b/tests/test_biped_leg_component.py
@@ -0,0 +1,342 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.biped_leg as leg
+import os
+import tempfile
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Leg_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for leg module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_leg_inst(self, prefix):
+
+        root.Root()
+        leg_inst = leg.BipedLeg(prefix=prefix)
+        leg_inst.parent = "root"
+        return leg_inst
+
+    def test_create_leg(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+
+        l_leg_inst.num_calf_twists = 2
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 7)
+
+        l_leg_inst.num_thigh_twists = 2
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 9)
+
+        l_leg_inst.has_ball_joint = False
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 7)
+
+        l_leg_inst.has_ball_joint = True
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 9)
+
+    def test_invalid_property_value(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_calf_twists = 5.5
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.has_ball_joint = 0
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_thigh_twists = 4
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_thigh_twists = "test"
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_thigh_twists = "2.5"
+
+    def test_copy_paste_settings(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        r_leg_inst = leg.BipedLeg(prefix="r", side="right")
+
+        l_leg_inst.num_calf_twists = 2
+        l_leg_inst.num_thigh_twists = 2
+        l_leg_inst.copy_settings()
+
+        self.assertEquals(r_leg_inst.num_thigh_twists, 0)
+        self.assertEquals(r_leg_inst.num_calf_twists, 0)
+
+        self.assertTrue(os.path.exists(os.path.join(tempfile.gettempdir(), "artv2Settings.txt")))
+
+        r_leg_inst.paste_settings()
+        self.assertEquals(r_leg_inst.num_thigh_twists, 2)
+        self.assertEquals(r_leg_inst.num_calf_twists, 2)
+
+    def test_reset_settings(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 5)
+
+        l_leg_inst.num_calf_twists = 2
+        l_leg_inst.num_thigh_twists = 2
+        l_leg_inst.has_ball_joint = False
+
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 7)
+
+        l_leg_inst.reset_settings()
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 5)
+        self.assertEquals(l_leg_inst.num_calf_twists, 0)
+        self.assertEquals(l_leg_inst.num_thigh_twists, 0)
+        self.assertEquals(l_leg_inst.has_ball_joint, True)
+
+    def test_delete_module(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        r_leg_inst = leg.BipedLeg(prefix="r", side="right")
+        l_leg_inst.parent = "root"
+        r_leg_inst.parent = "l_thigh"
+
+        component_containers = l_leg_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        l_leg_inst.delete()
+
+        self.assertFalse(cmds.objExists("l_leg_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(r_leg_inst.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        l_leg_inst.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("l_leg_calf_mover_offset.translateY", -30)
+
+        pre_offset_position = format_position(cmds.xform("l_leg_calf_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("l_leg_calf_mover", q=True, ws=True, t=True))
+        pre_foot_position = format_position(cmds.xform("l_leg_foot_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        l_leg_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("l_leg_calf_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("l_leg_calf_mover", q=True, ws=True, t=True))
+        post_foot_position = format_position(cmds.xform("l_leg_foot_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_foot_position, post_foot_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        l_leg_inst.parent = "root"
+
+        pre_leg_position = format_position(cmds.xform("l_leg_thigh_mover", q=True, ws=True, t=True))
+        l_leg_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(l_leg_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_leg_position = format_position(cmds.xform("l_leg_thigh_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_leg_position, post_leg_position)
+
+        l_leg_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_leg_position = format_position(cmds.xform("l_leg_thigh_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_leg_position, new_leg_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        l_leg_inst.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(l_leg_inst.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(l_leg_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee out and then test if the thigh offset orientations have changed.
+        original_orientation = cmds.xform("l_leg_thigh_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_leg_calf_mover_offset.translateY", -30)
+        new_orientation = cmds.xform("l_leg_thigh_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        # turn off aim mode and double check attrs once again
+        l_leg_inst.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(l_leg_inst.network_node.isAiming.get(), False)
+        self.assertEquals(len(l_leg_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee again and test if the thigh offset orientations did not change.
+        original_orientation = cmds.xform("l_leg_thigh_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_leg_calf_mover_offset.translateY", 0)
+        new_orientation = cmds.xform("l_leg_thigh_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_right_side(self):
+
+        self._create_asset()
+        root.Root()
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        r_leg_inst = leg.BipedLeg(prefix="r", side="right")
+        test_leg_inst = leg.BipedLeg(prefix="test")
+
+        l_joints = sorted(l_leg_inst.joint_mover.get_driven_joints())
+        r_joints = sorted(r_leg_inst.joint_mover.get_driven_joints())
+        test_joints = sorted(test_leg_inst.joint_mover.get_driven_joints())
+
+        for i in range(len(l_joints)):
+
+            l_joint = cmds.xform(l_joints[i].nodeName(), q=True, ws=True, ro=True)
+            r_joint = cmds.xform(r_joints[i].nodeName(), q=True, ws=True, ro=True)
+            test_joint = cmds.xform(test_joints[i].nodeName(), q=True, ws=True, ro=True)
+
+            self.assertNotEquals(l_joint, r_joint)
+            self.assertEquals(l_joint, test_joint)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        root.Root()
+        leg_inst = leg.BipedLeg(prefix="l", side="right")
+        leg_inst.num_thigh_twists = 2
+        leg_inst.parent = "root"
+
+        cmds.setAttr("l_leg_thigh_mover.translateZ", -65)
+        cmds.setAttr("l_leg_thigh_mover.rotateX", -3)
+        cmds.setAttr("l_leg_thigh_mover.rotateY", -8)
+        cmds.setAttr("l_leg_thigh_mover.rotateZ", 42)
+        cmds.setAttr("l_leg_thigh_mover.scaleX", .319)
+        cmds.setAttr("l_leg_thigh_mover.scaleY", .319)
+        cmds.setAttr("l_leg_thigh_mover.scaleZ", .319)
+
+        cmds.setAttr("l_leg_calf_mover.rotateX", 1.5)
+        cmds.setAttr("l_leg_calf_mover.rotateY", -27)
+        cmds.setAttr("l_leg_calf_mover.rotateZ", -45)
+
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        duplicate_inst = leg_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.num_thigh_twists, 2)
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover.tz"), cmds.getAttr("l_leg_thigh_mover.tz"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover.rx"), cmds.getAttr("l_leg_thigh_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover.ry"), cmds.getAttr("l_leg_thigh_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover.rz"), cmds.getAttr("l_leg_thigh_mover.rz"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover.sx"), cmds.getAttr("l_leg_thigh_mover.sx"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover.sy"), cmds.getAttr("l_leg_thigh_mover.sy"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover.sz"), cmds.getAttr("l_leg_thigh_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("l_leg_01_calf_mover.rx"), cmds.getAttr("l_leg_calf_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_leg_01_calf_mover.ry"), cmds.getAttr("l_leg_calf_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_leg_01_calf_mover.rz"), cmds.getAttr("l_leg_calf_mover.rz"))
+
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover_grp.sx"), cmds.getAttr("l_leg_thigh_mover_grp.sx"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover_grp.sy"), cmds.getAttr("l_leg_thigh_mover_grp.sy"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover_grp.sz"), cmds.getAttr("l_leg_thigh_mover_grp.sz"))
+        self.assertEquals(cmds.getAttr("l_leg_01_thigh_mover_grp.tz"), cmds.getAttr("l_leg_thigh_mover_grp.tz"))
+
+        dupe2 = leg_inst.duplicate()
+        dupe3 = leg_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        root.Root()
+        left_leg_inst = leg.BipedLeg(prefix="l")
+        left_leg_inst.parent = "root"
+
+        cmds.setAttr("l_leg_thigh_mover.translateZ", -20)
+        cmds.setAttr("l_leg_thigh_mover.rotateX", 40)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_leg_inst = left_leg_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = left_leg_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_leg_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_leg_thigh_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_leg_thigh_mover.rotateX"), 40)
+        self.assertEquals(cmds.getAttr("r_leg_thigh_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator()[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        root.Root()
+        left_leg_inst = leg.BipedLeg(prefix="l")
+        left_leg_inst.parent = "root"
+        right_leg_inst = left_leg_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_leg_inst.delete()
+
+        self.assertEquals(right_leg_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_leg_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        root.Root()
+        left_leg_inst = leg.BipedLeg(prefix="l")
+        left_leg_inst.parent = "root"
+        left_leg_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("l_leg_thigh_mover.translateZ", -20)
+        cmds.setAttr("l_leg_thigh_mover.rotateX", 40)
+
+        left_leg_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_leg_thigh_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_leg_thigh_mover.rotateX"), 40)
+
diff --git a/tests/test_camera_component.py b/tests/test_camera_component.py
new file mode 100644
index 0000000..27200e6
--- /dev/null
+++ b/tests/test_camera_component.py
@@ -0,0 +1,113 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.camera as camera
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Camera_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for camera component creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_camera_inst(self):
+
+        root.Root()
+        inst = camera.Camera()
+        inst.parent = "root"
+        return inst
+
+    def test_create_camera(self):
+
+        self._create_asset()
+        jnt_inst = self._create_camera_inst()
+        self.assertEquals(len(jnt_inst.joint_mover.get_created_joints()), 3)
+
+    def test_delete_camera(self):
+
+        self._create_asset()
+        jnt_inst = self._create_camera_inst()
+
+        component_containers = jnt_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        jnt_inst.delete()
+        self.assertFalse(cmds.objExists("camera_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        jnt_inst = self._create_camera_inst()
+        cmds.setAttr("camera_camera_main_mover_offset.translateY", 60)
+
+        pre_offset_position = format_position(cmds.xform("camera_camera_main_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("camera_camera_main_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+        jnt_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("camera_camera_main_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("camera_camera_main_mover", q=True, ws=True, t=True))
+        self.assertEquals(post_main_position, post_offset_position)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        jnt_inst = self._create_camera_inst()
+
+        cmds.setAttr("camera_camera_root_mover.translateZ", 65)
+        cmds.setAttr("camera_camera_root_mover.rotateX", 20)
+        cmds.setAttr("camera_camera_root_mover.rotateY", -20)
+        cmds.setAttr("camera_camera_root_mover.rotateZ", 42)
+        cmds.setAttr("camera_camera_root_mover.scaleX", 2)
+        cmds.setAttr("camera_camera_root_mover.scaleY", 2)
+        cmds.setAttr("camera_camera_root_mover.scaleZ", 2)
+
+        duplicate_inst = jnt_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.tz"), cmds.getAttr("camera_camera_root_mover.tz"))
+        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.rx"), cmds.getAttr("camera_camera_root_mover.rx"))
+        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.ry"), cmds.getAttr("camera_camera_root_mover.ry"))
+        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.rz"), cmds.getAttr("camera_camera_root_mover.rz"))
+        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.sx"), cmds.getAttr("camera_camera_root_mover.sx"))
+        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.sy"), cmds.getAttr("camera_camera_root_mover.sy"))
+        self.assertEquals(cmds.getAttr("camera_01_camera_root_mover.sz"), cmds.getAttr("camera_camera_root_mover.sz"))
+
+        dupe2 = jnt_inst.duplicate()
+        dupe3 = jnt_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        jnt_inst = self._create_camera_inst()
+
+        pre_position = format_position(cmds.xform("camera_camera_root_mover", q=True, ws=True, t=True))
+        jnt_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(jnt_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("camera_camera_root_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        jnt_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("camera_camera_root_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
diff --git a/tests/test_chain_component.py b/tests/test_chain_component.py
new file mode 100644
index 0000000..1206947
--- /dev/null
+++ b/tests/test_chain_component.py
@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+"""
+:author:
+    Jeremy Ernst
+:description:
+    This module contains unit tests for the chain component.
+"""
+
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.chain as chain
+import artv2.components.joint as joint
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Chain_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for chain module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_chain_inst(self, prefix):
+        if not cmds.objExists("master_metadata"):
+            root.Root()
+        chain_inst = chain.Chain(prefix=prefix)
+        chain_inst.parent = "root"
+        return chain_inst
+
+    def test_create_chain(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+        self.assertEquals(len(chain_inst.joint_mover.get_created_joints()), 3)
+
+    def test_delete_chain(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+        joint_inst = joint.Joint()
+        joint_inst.parent = "chain_03"
+
+        component_containers = chain_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+        chain_inst.delete()
+
+        self.assertFalse(cmds.objExists("chain_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(joint_inst.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+        chain_inst.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("chain_chain_02_mover_offset.translateY", 10)
+
+        pre_offset_position = format_position(cmds.xform("chain_chain_02_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("chain_chain_02_mover", q=True, ws=True, t=True))
+        pre_end_position = format_position(cmds.xform("chain_chain_03_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        chain_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("chain_chain_02_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("chain_chain_02_mover", q=True, ws=True, t=True))
+        post_end_position = format_position(cmds.xform("chain_chain_03_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_end_position, post_end_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+
+        pre_position = format_position(cmds.xform("chain_chain_01_mover", q=True, ws=True, t=True))
+        chain_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(chain_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("chain_chain_01_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        chain_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("chain_chain_01_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+        chain_inst.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(chain_inst.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(chain_inst.network_node.aimModeConstraints.connections()), 0)
+
+        original_orientation = cmds.xform("chain_chain_01_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("chain_chain_02_mover.translateY", 10)
+        new_orientation = cmds.xform("chain_chain_01_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        chain_inst.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(chain_inst.network_node.isAiming.get(), False)
+        self.assertEquals(len(chain_inst.network_node.aimModeConstraints.connections()), 0)
+
+        original_orientation = cmds.xform("chain_chain_01_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("chain_chain_02_mover.translateY", 0)
+        new_orientation = cmds.xform("chain_chain_01_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+
+        cmds.setAttr("chain_chain_01_mover.translateY", -10)
+        cmds.setAttr("chain_chain_01_mover.rotateY", 30)
+        cmds.setAttr("chain_chain_01_mover.rotateZ", 42)
+        cmds.setAttr("chain_chain_01_mover.scaleY", 1.319)
+        cmds.setAttr("chain_chain_01_mover.scaleX", 1.319)
+        cmds.setAttr("chain_chain_01_mover.scaleZ", 1.319)
+        cmds.setAttr("chain_chain_02_mover.rotateZ", -25)
+
+        duplicate_inst = chain_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("chain_01_chain_01_mover.ty"), cmds.getAttr("chain_chain_01_mover.ty"))
+        self.assertEquals(cmds.getAttr("chain_01_chain_01_mover.ry"), cmds.getAttr("chain_chain_01_mover.ry"))
+        self.assertEquals(cmds.getAttr("chain_01_chain_01_mover.rz"), cmds.getAttr("chain_chain_01_mover.rz"))
+        self.assertEquals(cmds.getAttr("chain_01_chain_01_mover.sx"), cmds.getAttr("chain_chain_01_mover.sx"))
+        self.assertEquals(cmds.getAttr("chain_01_chain_01_mover.sy"), cmds.getAttr("chain_chain_01_mover.sy"))
+        self.assertEquals(cmds.getAttr("chain_01_chain_01_mover.sz"), cmds.getAttr("chain_chain_01_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("chain_01_chain_02_mover.rz"), cmds.getAttr("chain_chain_02_mover.rz"))
+        chain_inst.num_joints = 5
+        dupe2 = chain_inst.duplicate()
+        dupe3 = chain_inst.duplicate()
+        dupe4 = chain_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+        self.assertEquals(dupe4.suffix, "_04")
+
+    def test_invalid_property_values(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+
+        with self.assertRaises(RuntimeError):
+            chain_inst.num_joints = 100
+
+        with self.assertRaises(RuntimeError):
+            chain_inst.num_joints = 3.5
+
+        with self.assertRaises(RuntimeError):
+            chain_inst.num_joints = "3"
+
+        with self.assertRaises(RuntimeError):
+            chain_inst.num_joints = 0
+
+    def test_num_spine_bones(self):
+
+        self._create_asset()
+        chain_inst = self._create_chain_inst("")
+        chain_inst.num_joints = 10
+        joint_inst = joint.Joint()
+        joint_inst.parent = "chain_10"
+        chain_inst.num_joints = 3
+        self.assertEquals(joint_inst.parent, "root")
+        chain_inst.num_joints = 5
+
+    def test_right_side(self):
+
+        self._create_asset()
+        l_chain_inst = self._create_chain_inst("l")
+        r_chain_inst = self._create_chain_inst("r")
+        r_chain_inst.set_side("right")
+        test_chain_inst = self._create_chain_inst("test")
+
+        l_joints = sorted(l_chain_inst.joint_mover.get_driven_joints())
+        r_joints = sorted(r_chain_inst.joint_mover.get_driven_joints())
+        test_joints = sorted(test_chain_inst.joint_mover.get_driven_joints())
+
+        for i in range(len(l_joints)):
+
+            l_joint = cmds.xform(l_joints[i].nodeName(), q=True, ws=True, ro=True)
+            r_joint = cmds.xform(r_joints[i].nodeName(), q=True, ws=True, ro=True)
+            test_joint = cmds.xform(test_joints[i].nodeName(), q=True, ws=True, ro=True)
+
+            self.assertNotEquals(l_joint, r_joint)
+            self.assertEquals(l_joint, test_joint)
+
+    def test_set_side(self):
+
+        self._create_asset()
+        l_chain_inst = self._create_chain_inst("l_index")
+        l_chain_inst.set_side("right")
+        l_chain_inst.set_side("left")
+
+        l_chain_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        left_chain_inst = self._create_chain_inst("l")
+
+        cmds.setAttr("l_chain_chain_01_mover.translateZ", -20)
+        cmds.setAttr("l_chain_chain_01_mover.rotateZ", 40)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_chain_inst = left_chain_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = left_chain_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_chain_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_chain_chain_01_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_chain_chain_01_mover.rotateZ"), 40)
+        self.assertEquals(cmds.getAttr("r_chain_chain_01_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator()[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        left_chain_inst = self._create_chain_inst("l")
+        right_chain_inst = left_chain_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_chain_inst.delete()
+
+        self.assertEquals(right_chain_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_chain_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        left_chain_inst = self._create_chain_inst("l")
+        left_chain_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("l_chain_chain_01_mover.translateZ", -20)
+        cmds.setAttr("l_chain_chain_01_mover.rotateZ", 40)
+
+        left_chain_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_chain_chain_01_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_chain_chain_01_mover.rotateZ"), 40)
diff --git a/tests/test_finger_component.py b/tests/test_finger_component.py
new file mode 100644
index 0000000..8a312cd
--- /dev/null
+++ b/tests/test_finger_component.py
@@ -0,0 +1,239 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.finger as finger
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Finger_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for finger module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_finger_inst(self, prefix):
+        if not cmds.objExists("master_metadata"):
+            root.Root()
+        finger_inst = finger.Finger(prefix=prefix)
+        finger_inst.parent = "root"
+        return finger_inst
+
+    def test_create_finger(self):
+
+        self._create_asset()
+        finger_inst = self._create_finger_inst("l_index")
+        self.assertEquals(len(finger_inst.joint_mover.get_created_joints()), 4)
+
+    def test_delete_finger(self):
+
+        self._create_asset()
+        l_finger_inst = self._create_finger_inst("l_index")
+        r_finger_inst = self._create_finger_inst("r_index")
+        r_finger_inst.set_side("right")
+        r_finger_inst.parent = "l_index_finger_01"
+
+        component_containers = l_finger_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+        l_finger_inst.delete()
+
+        self.assertFalse(cmds.objExists("l_index_finger_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(r_finger_inst.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        l_finger_inst = self._create_finger_inst("l_index")
+        l_finger_inst.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("l_index_finger_finger_02_mover_offset.translateY", 5)
+
+        pre_offset_position = format_position(cmds.xform("l_index_finger_finger_02_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("l_index_finger_finger_02_mover", q=True, ws=True, t=True))
+        pre_end_position = format_position(cmds.xform("l_index_finger_finger_03_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        l_finger_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("l_index_finger_finger_02_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("l_index_finger_finger_02_mover", q=True, ws=True, t=True))
+        post_end_position = format_position(cmds.xform("l_index_finger_finger_03_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_end_position, post_end_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        l_finger_inst = self._create_finger_inst("l_index")
+
+        pre_position = format_position(cmds.xform("l_index_finger_finger_01_mover", q=True, ws=True, t=True))
+        l_finger_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(l_finger_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("l_index_finger_finger_01_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        l_finger_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("l_index_finger_finger_01_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        l_finger_inst = self._create_finger_inst("l_index")
+        l_finger_inst.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(l_finger_inst.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(l_finger_inst.network_node.aimModeConstraints.connections()), 0)
+
+        original_orientation = cmds.xform("l_index_finger_finger_01_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_index_finger_finger_02_mover_offset.translateY", 5)
+        new_orientation = cmds.xform("l_index_finger_finger_01_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        l_finger_inst.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(l_finger_inst.network_node.isAiming.get(), False)
+        self.assertEquals(len(l_finger_inst.network_node.aimModeConstraints.connections()), 0)
+
+        original_orientation = cmds.xform("l_index_finger_finger_01_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_index_finger_finger_02_mover_offset.translateY", 0)
+        new_orientation = cmds.xform("l_index_finger_finger_01_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_right_side(self):
+
+        self._create_asset()
+        l_finger_inst = self._create_finger_inst("l_index")
+        r_finger_inst = self._create_finger_inst("r_index")
+        r_finger_inst.set_side("right")
+        test_finger_inst = self._create_finger_inst("test")
+
+        l_joints = sorted(l_finger_inst.joint_mover.get_driven_joints())
+        r_joints = sorted(r_finger_inst.joint_mover.get_driven_joints())
+        test_joints = sorted(test_finger_inst.joint_mover.get_driven_joints())
+
+        for i in range(len(l_joints)):
+
+            l_joint = cmds.xform(l_joints[i].nodeName(), q=True, ws=True, ro=True)
+            r_joint = cmds.xform(r_joints[i].nodeName(), q=True, ws=True, ro=True)
+            test_joint = cmds.xform(test_joints[i].nodeName(), q=True, ws=True, ro=True)
+
+            self.assertNotEquals(l_joint, r_joint)
+            self.assertEquals(l_joint, test_joint)
+
+    def test_set_side(self):
+
+        self._create_asset()
+        l_finger_inst = self._create_finger_inst("l_index")
+        l_finger_inst.set_side("right")
+        l_finger_inst.set_side("left")
+
+        l_finger_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        finger_isnt = self._create_finger_inst("l_index")
+
+        cmds.setAttr("l_index_finger_finger_01_mover.translateY", -10)
+        cmds.setAttr("l_index_finger_finger_01_mover.rotateY", 30)
+        cmds.setAttr("l_index_finger_finger_01_mover.rotateZ", 42)
+        cmds.setAttr("l_index_finger_finger_01_mover.scaleX", 1.319)
+        cmds.setAttr("l_index_finger_finger_01_mover.scaleY", 1.319)
+        cmds.setAttr("l_index_finger_finger_01_mover.scaleZ", 1.319)
+        cmds.setAttr("l_index_finger_finger_02_mover.rotateZ", 42)
+
+        duplicate_inst = finger_isnt.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("l_index_finger_01_finger_01_mover.ty"), cmds.getAttr("l_index_finger_finger_01_mover.ty"))
+        self.assertEquals(cmds.getAttr("l_index_finger_01_finger_01_mover.ry"), cmds.getAttr("l_index_finger_finger_01_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_index_finger_01_finger_01_mover.rz"), cmds.getAttr("l_index_finger_finger_01_mover.rz"))
+        self.assertEquals(cmds.getAttr("l_index_finger_01_finger_01_mover.sx"), cmds.getAttr("l_index_finger_finger_01_mover.sx"))
+        self.assertEquals(cmds.getAttr("l_index_finger_01_finger_01_mover.sy"), cmds.getAttr("l_index_finger_finger_01_mover.sy"))
+        self.assertEquals(cmds.getAttr("l_index_finger_01_finger_01_mover.sz"), cmds.getAttr("l_index_finger_finger_01_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("l_index_finger_01_finger_02_mover.rz"), cmds.getAttr("l_index_finger_finger_02_mover.rz"))
+        dupe2 = finger_isnt.duplicate()
+        dupe3 = finger_isnt.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        left_finger_inst = self._create_finger_inst("l_index")
+
+        cmds.setAttr("l_index_finger_finger_01_mover.translateZ", -20)
+        cmds.setAttr("l_index_finger_finger_01_mover.rotateZ", 40)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_finger_inst = left_finger_inst.create_mirror(prefix="r_index", suffix="", parent="root")
+
+        left_movers = left_finger_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_finger_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_index_finger_finger_01_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_index_finger_finger_01_mover.rotateZ"), 40)
+        self.assertEquals(cmds.getAttr("r_index_finger_finger_01_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator()[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        left_finger_inst = self._create_finger_inst("l_index")
+        right_finger_inst = left_finger_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_finger_inst.delete()
+
+        self.assertEquals(right_finger_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_finger_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        left_finger_inst = self._create_finger_inst("l_index")
+        left_finger_inst.create_mirror(prefix="r_index", suffix="", parent="root")
+
+        cmds.setAttr("l_index_finger_finger_01_mover.translateZ", -20)
+        cmds.setAttr("l_index_finger_finger_01_mover.rotateZ", 40)
+
+        left_finger_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_index_finger_finger_01_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_index_finger_finger_01_mover.rotateZ"), 40)
diff --git a/tests/test_hind_leg_component.py b/tests/test_hind_leg_component.py
new file mode 100644
index 0000000..6ef9b89
--- /dev/null
+++ b/tests/test_hind_leg_component.py
@@ -0,0 +1,336 @@
+# -*- coding: utf-8 -*-
+"""
+:author:
+    Jeremy Ernst
+:description:
+    This module contains the unit tests for the hind leg class
+
+"""
+
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.hind_leg as leg
+import os
+import tempfile
+
+
+def format_position(pos):
+    return [float("{0:.2f}".format(pos[0])), float("{0:.2f}".format(pos[1])), float("{0:.2f}".format(pos[2]))]
+
+
+class HindLeg_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for hind leg module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_leg_inst(self, prefix):
+        if not cmds.objExists("master_metadata"):
+            root.Root()
+        leg_inst = leg.HindLeg(prefix=prefix)
+        leg_inst.parent = "root"
+        return leg_inst
+
+    def test_create_leg(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+
+        l_leg_inst.num_calf_twists = 2
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 8)
+
+        l_leg_inst.num_thigh_twists = 2
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 10)
+
+        l_leg_inst.has_ball_joint = False
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 8)
+
+        l_leg_inst.has_ball_joint = True
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 10)
+
+    def test_invalid_property_value(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_calf_twists = 5.5
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.has_ball_joint = 0
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_thigh_twists = 4
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_thigh_twists = "test"
+
+        with self.assertRaises(RuntimeError):
+            l_leg_inst.num_thigh_twists = "2.5"
+
+    def test_copy_paste_settings(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+        r_leg_inst = self._create_leg_inst("r")
+        r_leg_inst.set_side("right")
+
+        l_leg_inst.num_calf_twists = 2
+        l_leg_inst.num_thigh_twists = 2
+        l_leg_inst.copy_settings()
+
+        self.assertEquals(r_leg_inst.num_thigh_twists, 0)
+        self.assertEquals(r_leg_inst.num_calf_twists, 0)
+
+        self.assertTrue(os.path.exists(os.path.join(tempfile.gettempdir(), "artv2Settings.txt")))
+
+        r_leg_inst.paste_settings()
+        self.assertEquals(r_leg_inst.num_thigh_twists, 2)
+        self.assertEquals(r_leg_inst.num_calf_twists, 2)
+
+    def test_reset_settings(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 6)
+
+        l_leg_inst.num_calf_twists = 2
+        l_leg_inst.num_thigh_twists = 2
+        l_leg_inst.has_ball_joint = False
+
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 8)
+
+        l_leg_inst.reset_settings()
+        self.assertEquals(len(l_leg_inst.joint_mover.get_created_joints()), 6)
+        self.assertEquals(l_leg_inst.num_calf_twists, 0)
+        self.assertEquals(l_leg_inst.num_thigh_twists, 0)
+        self.assertEquals(l_leg_inst.has_ball_joint, True)
+
+    def test_delete_module(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+        r_leg_inst = self._create_leg_inst("r")
+        r_leg_inst.set_side("right")
+        r_leg_inst.parent = "l_thigh"
+
+        component_containers = l_leg_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        l_leg_inst.delete()
+
+        self.assertFalse(cmds.objExists("l_hindleg_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(r_leg_inst.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+        l_leg_inst.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("l_hindleg_calf_mover_offset.translateY", -30)
+
+        pre_offset_position = format_position(cmds.xform("l_hindleg_calf_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("l_hindleg_calf_mover", q=True, ws=True, t=True))
+        pre_foot_position = format_position(cmds.xform("l_hindleg_foot_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        l_leg_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("l_hindleg_calf_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("l_hindleg_calf_mover", q=True, ws=True, t=True))
+        post_foot_position = format_position(cmds.xform("l_hindleg_foot_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_foot_position, post_foot_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+
+        pre_leg_position = format_position(cmds.xform("l_hindleg_thigh_mover", q=True, ws=True, t=True))
+        l_leg_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(l_leg_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_leg_position = format_position(cmds.xform("l_hindleg_thigh_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_leg_position, post_leg_position)
+
+        l_leg_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_leg_position = format_position(cmds.xform("l_hindleg_thigh_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_leg_position, new_leg_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+        l_leg_inst.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(l_leg_inst.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(l_leg_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee out and then test if the thigh offset orientations have changed.
+        original_orientation = cmds.xform("l_hindleg_thigh_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_hindleg_calf_mover_offset.translateY", -30)
+        new_orientation = cmds.xform("l_hindleg_thigh_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        # turn off aim mode and double check attrs once again
+        l_leg_inst.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(l_leg_inst.network_node.isAiming.get(), False)
+        self.assertEquals(len(l_leg_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee again and test if the thigh offset orientations did not change.
+        original_orientation = cmds.xform("l_hindleg_thigh_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_hindleg_calf_mover_offset.translateY", 0)
+        new_orientation = cmds.xform("l_hindleg_thigh_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_right_side(self):
+
+        self._create_asset()
+        l_leg_inst = self._create_leg_inst("l")
+        r_leg_inst = self._create_leg_inst("r")
+        r_leg_inst.set_side("right")
+        test_leg_inst = self._create_leg_inst("test")
+
+        l_joints = sorted(l_leg_inst.joint_mover.get_driven_joints())
+        r_joints = sorted(r_leg_inst.joint_mover.get_driven_joints())
+        test_joints = sorted(test_leg_inst.joint_mover.get_driven_joints())
+
+        for i in range(len(l_joints)):
+
+            l_joint = cmds.xform(l_joints[i].nodeName(), q=True, ws=True, ro=True)
+            r_joint = cmds.xform(r_joints[i].nodeName(), q=True, ws=True, ro=True)
+            test_joint = cmds.xform(test_joints[i].nodeName(), q=True, ws=True, ro=True)
+
+            self.assertNotEquals(l_joint, r_joint)
+            self.assertEquals(l_joint, test_joint)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        leg_inst = self._create_leg_inst("l")
+        leg_inst.num_thigh_twists = 2
+
+        cmds.setAttr("l_hindleg_thigh_mover.translateZ", -65)
+        cmds.setAttr("l_hindleg_thigh_mover.rotateX", -3)
+        cmds.setAttr("l_hindleg_thigh_mover.rotateY", -8)
+        cmds.setAttr("l_hindleg_thigh_mover.rotateZ", 42)
+        cmds.setAttr("l_hindleg_thigh_mover.scaleX", .319)
+        cmds.setAttr("l_hindleg_thigh_mover.scaleY", .319)
+        cmds.setAttr("l_hindleg_thigh_mover.scaleZ", .319)
+
+        cmds.setAttr("l_hindleg_calf_mover.rotateX", 1.5)
+        cmds.setAttr("l_hindleg_calf_mover.rotateY", -27)
+        cmds.setAttr("l_hindleg_calf_mover.rotateZ", -45)
+
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        duplicate_inst = leg_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.num_thigh_twists, 2)
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover.tz"), cmds.getAttr("l_hindleg_thigh_mover.tz"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover.rx"), cmds.getAttr("l_hindleg_thigh_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover.ry"), cmds.getAttr("l_hindleg_thigh_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover.rz"), cmds.getAttr("l_hindleg_thigh_mover.rz"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover.sx"), cmds.getAttr("l_hindleg_thigh_mover.sx"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover.sy"), cmds.getAttr("l_hindleg_thigh_mover.sy"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover.sz"), cmds.getAttr("l_hindleg_thigh_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("l_hindleg_01_calf_mover.rx"), cmds.getAttr("l_hindleg_calf_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_calf_mover.ry"), cmds.getAttr("l_hindleg_calf_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_calf_mover.rz"), cmds.getAttr("l_hindleg_calf_mover.rz"))
+
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover_grp.sx"), cmds.getAttr("l_hindleg_thigh_mover_grp.sx"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover_grp.sy"), cmds.getAttr("l_hindleg_thigh_mover_grp.sy"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover_grp.sz"), cmds.getAttr("l_hindleg_thigh_mover_grp.sz"))
+        self.assertEquals(cmds.getAttr("l_hindleg_01_thigh_mover_grp.tz"), cmds.getAttr("l_hindleg_thigh_mover_grp.tz"))
+
+        dupe2 = leg_inst.duplicate()
+        dupe3 = leg_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        left_leg_inst = self._create_leg_inst("l")
+
+        cmds.setAttr("l_hindleg_thigh_mover.translateZ", -20)
+        cmds.setAttr("l_hindleg_thigh_mover.rotateX", 40)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_leg_inst = left_leg_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = left_leg_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_leg_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_hindleg_thigh_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_hindleg_thigh_mover.rotateX"), 40)
+        self.assertEquals(cmds.getAttr("r_hindleg_thigh_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator()[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        left_leg_inst = self._create_leg_inst("l")
+        right_leg_inst = left_leg_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_leg_inst.delete()
+
+        self.assertEquals(right_leg_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_leg_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        left_leg_inst = self._create_leg_inst("l")
+        left_leg_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("l_hindleg_thigh_mover.translateZ", -20)
+        cmds.setAttr("l_hindleg_thigh_mover.rotateX", 40)
+
+        left_leg_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_hindleg_thigh_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_hindleg_thigh_mover.rotateX"), 40)
+
diff --git a/tests/test_hinge_component.py b/tests/test_hinge_component.py
new file mode 100644
index 0000000..1f26210
--- /dev/null
+++ b/tests/test_hinge_component.py
@@ -0,0 +1,265 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.hinge as hinge
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Hinge_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for hinge module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_hinge_inst(self, prefix):
+
+        root.Root()
+        hinge_inst = hinge.Hinge(prefix=prefix)
+        hinge_inst.parent = "root"
+        return hinge_inst
+
+    def test_create_hinge(self):
+
+        self._create_asset()
+        hinge_inst = self._create_hinge_inst("l")
+        self.assertEquals(len(hinge_inst.joint_mover.get_created_joints()), 3)
+
+    def test_delete_hinge(self):
+
+        self._create_asset()
+        root.Root()
+        l_hinge_inst = hinge.Hinge(prefix="l")
+        r_hinge_inst = hinge.Hinge(prefix="r", side="right")
+        l_hinge_inst.parent = "root"
+        r_hinge_inst.parent = "l_base"
+
+        component_containers = l_hinge_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        l_hinge_inst.delete()
+
+        self.assertFalse(cmds.objExists("l_hinge_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(r_hinge_inst.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        root.Root()
+        l_hinge_inst = hinge.Hinge(prefix="l")
+        l_hinge_inst.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("l_hinge_middle_mover_offset.translateY", 30)
+
+        pre_offset_position = format_position(cmds.xform("l_hinge_middle_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("l_hinge_middle_mover", q=True, ws=True, t=True))
+        pre_foot_position = format_position(cmds.xform("l_hinge_end_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        l_hinge_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("l_hinge_middle_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("l_hinge_middle_mover", q=True, ws=True, t=True))
+        post_foot_position = format_position(cmds.xform("l_hinge_end_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_foot_position, post_foot_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        root.Root()
+        l_hinge_inst = hinge.Hinge(prefix="l")
+        l_hinge_inst.parent = "root"
+
+        pre_position = format_position(cmds.xform("l_hinge_base_mover", q=True, ws=True, t=True))
+        l_hinge_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(l_hinge_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("l_hinge_base_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        l_hinge_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("l_hinge_base_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        root.Root()
+        l_hinge_inst = hinge.Hinge(prefix="l")
+        l_hinge_inst.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(l_hinge_inst.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(l_hinge_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee out and then test if the thigh offset orientations have changed.
+        original_orientation = cmds.xform("l_hinge_base_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_hinge_middle_mover_offset.translateY", 30)
+        new_orientation = cmds.xform("l_hinge_base_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        # turn off aim mode and double check attrs once again
+        l_hinge_inst.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(l_hinge_inst.network_node.isAiming.get(), False)
+        self.assertEquals(len(l_hinge_inst.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee again and test if the thigh offset orientations did not change.
+        original_orientation = cmds.xform("l_hinge_base_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_hinge_middle_mover_offset.translateY", 0)
+        new_orientation = cmds.xform("l_hinge_base_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_right_side(self):
+
+        self._create_asset()
+        root.Root()
+        l_hinge_inst = hinge.Hinge(prefix="l")
+        r_hinge_inst = hinge.Hinge(prefix="r", side="right")
+        test_hinge_inst = hinge.Hinge(prefix="test")
+
+        l_joints = sorted(l_hinge_inst.joint_mover.get_driven_joints())
+        r_joints = sorted(r_hinge_inst.joint_mover.get_driven_joints())
+        test_joints = sorted(test_hinge_inst.joint_mover.get_driven_joints())
+
+        for i in range(len(l_joints)):
+
+            l_joint = cmds.xform(l_joints[i].nodeName(), q=True, ws=True, ro=True)
+            r_joint = cmds.xform(r_joints[i].nodeName(), q=True, ws=True, ro=True)
+            test_joint = cmds.xform(test_joints[i].nodeName(), q=True, ws=True, ro=True)
+
+            self.assertNotEquals(l_joint, r_joint)
+            self.assertEquals(l_joint, test_joint)
+
+    def test_set_side(self):
+
+        self._create_asset()
+        root.Root()
+        l_hinge_inst = hinge.Hinge(prefix="l")
+        l_hinge_inst.parent = "root"
+        l_hinge_inst.set_side("right")
+        l_hinge_inst.set_side("left")
+
+        l_hinge_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        root.Root()
+        hinge_inst = hinge.Hinge(prefix="l", side="right")
+        hinge_inst.parent = "root"
+
+        cmds.setAttr("l_hinge_base_mover.translateZ", -65)
+        cmds.setAttr("l_hinge_base_mover.rotateX", -3)
+        cmds.setAttr("l_hinge_base_mover.rotateY", -8)
+        cmds.setAttr("l_hinge_base_mover.rotateZ", 42)
+        cmds.setAttr("l_hinge_base_mover.scaleX", .319)
+        cmds.setAttr("l_hinge_base_mover.scaleY", .319)
+        cmds.setAttr("l_hinge_base_mover.scaleZ", .319)
+
+        cmds.setAttr("l_hinge_middle_mover.rotateX", 1.5)
+        cmds.setAttr("l_hinge_middle_mover.rotateY", -27)
+        cmds.setAttr("l_hinge_middle_mover.rotateZ", -45)
+
+        duplicate_inst = hinge_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("l_hinge_01_base_mover.tz"), cmds.getAttr("l_hinge_base_mover.tz"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_base_mover.rx"), cmds.getAttr("l_hinge_base_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_base_mover.ry"), cmds.getAttr("l_hinge_base_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_base_mover.rz"), cmds.getAttr("l_hinge_base_mover.rz"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_base_mover.sx"), cmds.getAttr("l_hinge_base_mover.sx"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_base_mover.sy"), cmds.getAttr("l_hinge_base_mover.sy"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_base_mover.sz"), cmds.getAttr("l_hinge_base_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("l_hinge_01_middle_mover.rx"), cmds.getAttr("l_hinge_middle_mover.rx"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_middle_mover.ry"), cmds.getAttr("l_hinge_middle_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_hinge_01_middle_mover.rz"), cmds.getAttr("l_hinge_middle_mover.rz"))
+        dupe2 = hinge_inst.duplicate()
+        dupe3 = hinge_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        root.Root()
+        left_hinge_inst = hinge.Hinge(prefix="l")
+        left_hinge_inst.parent = "root"
+
+        cmds.setAttr("l_hinge_base_mover.translateZ", -20)
+        cmds.setAttr("l_hinge_base_mover.rotateX", 40)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_hinge_inst = left_hinge_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = left_hinge_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_hinge_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_hinge_base_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_hinge_base_mover.rotateX"), 40)
+        self.assertEquals(cmds.getAttr("r_hinge_base_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator()[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        root.Root()
+        left_hinge_inst = hinge.Hinge(prefix="l")
+        left_hinge_inst.parent = "root"
+        right_hinge_inst = left_hinge_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_hinge_inst.delete()
+
+        self.assertEquals(right_hinge_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_hinge_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        root.Root()
+        left_hinge_inst = hinge.Hinge(prefix="l")
+        left_hinge_inst.parent = "root"
+        left_hinge_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("l_hinge_base_mover.translateZ", -20)
+        cmds.setAttr("l_hinge_base_mover.rotateX", 40)
+
+        left_hinge_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_hinge_base_mover.translateZ"), 20)
+        self.assertEquals(cmds.getAttr("r_hinge_base_mover.rotateX"), 40)
diff --git a/tests/test_joint_component.py b/tests/test_joint_component.py
new file mode 100644
index 0000000..28b3e1d
--- /dev/null
+++ b/tests/test_joint_component.py
@@ -0,0 +1,170 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.joint as joint
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Joint_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for joint module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_joint_inst(self, prefix):
+
+        root.Root()
+        jnt_inst = joint.Joint(prefix=prefix)
+        jnt_inst.parent = "root"
+        return jnt_inst
+
+    def test_create_joint(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        self.assertEquals(len(jnt_inst.joint_mover.get_created_joints()), 1)
+
+    def test_delete_root(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        component_containers = jnt_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        jnt_inst.delete()
+        self.assertFalse(cmds.objExists("test_joint_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        cmds.setAttr("test_joint_jnt_mover_offset.translateY", 30)
+
+        pre_offset_position = format_position(cmds.xform("test_joint_jnt_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+        jnt_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("test_joint_jnt_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertEquals(post_main_position, post_offset_position)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        cmds.setAttr("test_joint_jnt_mover.translateZ", -65)
+        cmds.setAttr("test_joint_jnt_mover.rotateX", -3)
+        cmds.setAttr("test_joint_jnt_mover.rotateY", -8)
+        cmds.setAttr("test_joint_jnt_mover.rotateZ", 42)
+        cmds.setAttr("test_joint_jnt_mover.scaleX", .319)
+        cmds.setAttr("test_joint_jnt_mover.scaleY", .319)
+        cmds.setAttr("test_joint_jnt_mover.scaleZ", .319)
+
+        duplicate_inst = jnt_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.tz"), cmds.getAttr("test_joint_jnt_mover.tz"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.rx"), cmds.getAttr("test_joint_jnt_mover.rx"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.ry"), cmds.getAttr("test_joint_jnt_mover.ry"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.rz"), cmds.getAttr("test_joint_jnt_mover.rz"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.sx"), cmds.getAttr("test_joint_jnt_mover.sx"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.sy"), cmds.getAttr("test_joint_jnt_mover.sy"))
+        self.assertEquals(cmds.getAttr("test_joint_01_jnt_mover.sz"), cmds.getAttr("test_joint_jnt_mover.sz"))
+
+        dupe2 = jnt_inst.duplicate()
+        dupe3 = jnt_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        pre_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        jnt_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(jnt_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        jnt_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("test_joint_jnt_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+
+        cmds.setAttr("test_joint_jnt_mover.translateX", 30)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_jnt_inst = jnt_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = jnt_inst.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_jnt_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover.translateX"), -30)
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator(name=mover+"_loc")[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        right_jnt_inst = jnt_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        jnt_inst.delete()
+
+        self.assertEquals(right_jnt_inst.network_node.has_mirror.get(), False)
+        self.assertEquals(len(right_jnt_inst.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        jnt_inst = self._create_joint_inst("test")
+        jnt_inst.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("test_joint_jnt_mover.translateX", 20)
+        cmds.setAttr("test_joint_jnt_mover.rotateX", 40)
+
+        jnt_inst.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover.translateX"), -20)
+        self.assertEquals(cmds.getAttr("r_joint_jnt_mover.rotateX"), 40)
\ No newline at end of file
diff --git a/tests/test_rig_assets.py b/tests/test_rig_assets.py
new file mode 100644
index 0000000..db76c60
--- /dev/null
+++ b/tests/test_rig_assets.py
@@ -0,0 +1,50 @@
+
+import unittest
+import pymel.core as pm
+import artv2.components.base_components.rig_asset as rig_asset
+
+
+class Test_Rig_Assets(unittest.TestCase):
+
+    def test_create_and_rename_asset(self):
+        new_asset = rig_asset.RigAsset()
+        new_asset.name = "test"
+        self.assertEquals(new_asset.name, "test")
+
+    def test_create_multiple_assets(self):
+        asset1 = rig_asset.RigAsset()
+        self.assertEquals(asset1.name, "asset")
+
+        with self.assertRaises(RuntimeError):
+            asset2 = rig_asset.RigAsset()
+
+    def test_delete_asset(self):
+
+        asset = rig_asset.RigAsset()
+
+        with self.assertRaises(RuntimeError):
+            pm.delete(asset.network_node)
+
+        exists = pm.objExists(asset.network_node)
+        self.assertEquals(exists, True)
+
+    def test_invalid_asset_name(self):
+        new_asset = rig_asset.RigAsset()
+
+        with self.assertRaises(RuntimeError):
+            new_asset.name = "123test"
+
+        with self.assertRaises(RuntimeError):
+            new_asset.name = "x-man"
+
+        new_asset.name = "dummy"
+        self.assertEquals(new_asset.name, "dummy")
+
+    def test_access_asset_details(self):
+
+        new_asset = rig_asset.RigAsset()
+        new_asset.name = "dummy"
+        network_node = new_asset.network_node
+
+        access_asset = rig_asset.RigAsset(network_node)
+        self.assertEquals(access_asset.name, "dummy")
diff --git a/tests/test_root_component.py b/tests/test_root_component.py
new file mode 100644
index 0000000..5e99ef1
--- /dev/null
+++ b/tests/test_root_component.py
@@ -0,0 +1,76 @@
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Root_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for hinge module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_root_inst(self):
+
+        inst = root.Root()
+        return inst
+
+    def test_create_root(self):
+
+        self._create_asset()
+        arm_inst = self._create_root_inst()
+        self.assertEquals(len(arm_inst.joint_mover.get_created_joints()), 1)
+
+    def test_delete_root(self):
+
+        self._create_asset()
+        root_inst = self._create_root_inst()
+
+        component_containers = root_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+
+        root_inst.delete()
+        self.assertFalse(cmds.objExists("master_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        root_inst = root.Root()
+        cmds.setAttr("master_root_mover_offset.translateY", 30)
+
+        pre_offset_position = format_position(cmds.xform("master_root_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("master_root_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+        root_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("master_root_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("master_root_mover", q=True, ws=True, t=True))
+        self.assertEquals(post_main_position, post_offset_position)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        root_inst = root.Root()
+
+        dupe1 = root_inst.duplicate()
+        dupe2 = root_inst.duplicate()
+        dupe3 = root_inst.duplicate()
+
+        self.assertEquals(dupe1.suffix, "_01")
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
diff --git a/tests/test_segment_component.py b/tests/test_segment_component.py
new file mode 100644
index 0000000..732daf8
--- /dev/null
+++ b/tests/test_segment_component.py
@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+"""
+:author:
+    Jeremy Ernst
+:description:
+    This module contains unit tests for the segment component.
+"""
+
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.segment as segment
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Segment_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for segment component creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_segment_inst(self, prefix):
+
+        if not cmds.objExists("master_metadata"):
+            root.Root()
+        segment_inst = segment.Segment(prefix=prefix)
+        segment_inst.parent = "root"
+        return segment_inst
+
+    def test_create_segment(self):
+
+        self._create_asset()
+        hinge_inst = self._create_segment_inst("l")
+        self.assertEquals(len(hinge_inst.joint_mover.get_created_joints()), 2)
+
+    def test_delete_segment(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+        r_segment = self._create_segment_inst("r")
+        r_segment.set_side("right")
+        r_segment.parent = "l_start"
+
+        component_containers = l_segment.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+        l_segment.delete()
+
+        self.assertFalse(cmds.objExists("l_segment_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(r_segment.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+        l_segment.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("l_segment_start_mover_offset.translateY", 30)
+
+        pre_offset_position = format_position(cmds.xform("l_segment_start_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("l_segment_start_mover", q=True, ws=True, t=True))
+        pre_end_position = format_position(cmds.xform("l_segment_end_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        l_segment.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("l_segment_start_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("l_segment_start_mover", q=True, ws=True, t=True))
+        post_end_position = format_position(cmds.xform("l_segment_end_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_end_position, post_end_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+
+        pre_position = format_position(cmds.xform("l_segment_start_mover", q=True, ws=True, t=True))
+        l_segment.joint_mover.toggle_pin_component()
+        self.assertTrue(l_segment.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("l_segment_start_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        l_segment.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("l_segment_start_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+        l_segment.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(l_segment.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(l_segment.network_node.aimModeConstraints.connections()), 0)
+
+        original_orientation = cmds.xform("l_segment_start_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_segment_end_mover_offset.translateZ", 10)
+        new_orientation = cmds.xform("l_segment_start_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        # turn off aim mode and double check attrs once again
+        l_segment.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(l_segment.network_node.isAiming.get(), False)
+        self.assertEquals(len(l_segment.network_node.aimModeConstraints.connections()), 0)
+
+        # move the knee again and test if the thigh offset orientations did not change.
+        original_orientation = cmds.xform("l_segment_start_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("l_segment_end_mover_offset.translateZ", 0)
+        new_orientation = cmds.xform("l_segment_start_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_right_side(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+        r_segment = self._create_segment_inst("r")
+        test_segment = self._create_segment_inst("test")
+        r_segment.set_side("right")
+
+        l_joints = sorted(l_segment.joint_mover.get_driven_joints())
+        r_joints = sorted(r_segment.joint_mover.get_driven_joints())
+        test_joints = sorted(test_segment.joint_mover.get_driven_joints())
+
+        for i in range(len(l_joints)):
+
+            l_joint = cmds.xform(l_joints[i].nodeName(), q=True, ws=True, ro=True)
+            r_joint = cmds.xform(r_joints[i].nodeName(), q=True, ws=True, ro=True)
+            test_joint = cmds.xform(test_joints[i].nodeName(), q=True, ws=True, ro=True)
+
+            self.assertNotEquals(l_joint, r_joint)
+            self.assertEquals(l_joint, test_joint)
+
+    def test_set_side(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+        l_segment.set_side("right")
+        l_segment.set_side("left")
+
+        l_segment.create_mirror(prefix="r", suffix="", parent="root")
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        segment_inst = self._create_segment_inst("l")
+
+        cmds.setAttr("l_segment_start_mover.translateX", 10)
+        cmds.setAttr("l_segment_start_mover.translateZ", 30)
+        cmds.setAttr("l_segment_start_mover.rotateY", -8)
+        cmds.setAttr("l_segment_start_mover.rotateZ", -30)
+        cmds.setAttr("l_segment_start_mover.scaleX", 2)
+        cmds.setAttr("l_segment_start_mover.scaleY", 2)
+        cmds.setAttr("l_segment_start_mover.scaleZ", 2)
+
+        cmds.setAttr("l_segment_end_mover.translateX", 10)
+
+        duplicate_inst = segment_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("l_segment_01_start_mover.tx"), cmds.getAttr("l_segment_start_mover.tx"))
+        self.assertEquals(cmds.getAttr("l_segment_01_start_mover.tz"), cmds.getAttr("l_segment_start_mover.tz"))
+        self.assertEquals(cmds.getAttr("l_segment_01_start_mover.ry"), cmds.getAttr("l_segment_start_mover.ry"))
+        self.assertEquals(cmds.getAttr("l_segment_01_start_mover.rz"), cmds.getAttr("l_segment_start_mover.rz"))
+        self.assertEquals(cmds.getAttr("l_segment_01_start_mover.sx"), cmds.getAttr("l_segment_start_mover.sx"))
+        self.assertEquals(cmds.getAttr("l_segment_01_start_mover.sy"), cmds.getAttr("l_segment_start_mover.sy"))
+        self.assertEquals(cmds.getAttr("l_segment_01_start_mover.sz"), cmds.getAttr("l_segment_start_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("l_segment_01_end_mover.tx"), cmds.getAttr("l_segment_end_mover.tx"))
+        dupe2 = segment_inst.duplicate()
+        dupe3 = segment_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+
+    def test_create_mirror(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+
+        cmds.setAttr("l_segment_start_mover.translateZ", 20)
+        cmds.setAttr("l_segment_start_mover.rotateZ", -30)
+        cmds.setAttr("master_root_mover.scaleX", 2.5)
+        cmds.setAttr("master_root_mover.scaleY", 2.5)
+        cmds.setAttr("master_root_mover.scaleZ", 2.5)
+        cmds.setAttr("master_root_mover.translateZ", 60)
+
+        right_hinge_inst = l_segment.create_mirror(prefix="r", suffix="", parent="root")
+
+        left_movers = l_segment.joint_mover.get_movers()
+        left_global_movers = sorted(left_movers.get("global"))
+        right_movers = right_hinge_inst.joint_mover.get_movers()
+        right_global_movers = sorted(right_movers.get("global"))
+
+        self.assertEquals(cmds.getAttr("r_segment_start_mover.translateZ"), -20)
+        self.assertEquals(round(cmds.getAttr("r_segment_start_mover.rotateZ")), -30)
+        self.assertEquals(cmds.getAttr("r_segment_start_mover_grp.scaleX"), 2.5)
+
+        for mover in left_global_movers:
+            index = left_global_movers.index(mover)
+            loc = cmds.spaceLocator()[0]
+            cmds.delete(cmds.parentConstraint(mover.nodeName(), loc)[0])
+            group = cmds.group(empty=True)
+            cmds.parent(loc, group)
+            cmds.setAttr(group + ".scaleX", -1)
+
+            loc_pos = format_position(cmds.xform(loc, q=True, ws=True, t=True))
+            mirror_pos = format_position(cmds.xform(right_global_movers[index].nodeName(), q=True, ws=True, t=True))
+            self.assertEquals(loc_pos, mirror_pos)
+
+    def test_delete_mirror(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+        r_segment = l_segment.create_mirror(prefix="r", suffix="", parent="root")
+
+        l_segment.delete()
+
+        self.assertEquals(r_segment.network_node.has_mirror.get(), False)
+        self.assertEquals(len(r_segment.network_node.mirror_component.connections()), 0)
+
+    def test_mirror_transforms(self):
+
+        self._create_asset()
+        l_segment = self._create_segment_inst("l")
+        l_segment.create_mirror(prefix="r", suffix="", parent="root")
+
+        cmds.setAttr("l_segment_start_mover.translateZ", 20)
+        cmds.setAttr("l_segment_start_mover.rotateZ", -40)
+
+        l_segment.joint_mover.mirror_transforms()
+
+        self.assertEquals(cmds.getAttr("r_segment_start_mover.translateZ"), -20)
+        self.assertEquals(cmds.getAttr("r_segment_start_mover.rotateZ"), -40)
diff --git a/tests/test_spine_component.py b/tests/test_spine_component.py
new file mode 100644
index 0000000..cb2fa14
--- /dev/null
+++ b/tests/test_spine_component.py
@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""
+:author:
+    Jeremy Ernst
+:description:
+    This module contains unit tests for the spine component.
+"""
+
+import unittest
+import maya.cmds as cmds
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.spine as spine
+import artv2.components.joint as joint
+
+
+def format_position(pos):
+    return [float("{0:.3f}".format(pos[0])), float("{0:.3f}".format(pos[1])), float("{0:.3f}".format(pos[2]))]
+
+
+class Spine_Component_Tests(unittest.TestCase):
+    """
+    Class containing tests for spine module creation and manipulation.
+    """
+
+    def _create_asset(self):
+        new_asset = rig_asset.RigAsset()
+        self.assertEquals(new_asset.name, "asset")
+        self.assertEquals(new_asset.network_node, "asset_metadata")
+        return new_asset
+
+    def _create_spine_inst(self, prefix):
+        if not cmds.objExists("master_metadata"):
+            root.Root()
+        spine_inst = spine.Spine(prefix=prefix)
+        spine_inst.parent = "root"
+        return spine_inst
+
+    def test_create_spine(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+        self.assertEquals(len(spine_inst.joint_mover.get_created_joints()), 4)
+
+    def test_delete_spine(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+        joint_inst = joint.Joint()
+        joint_inst.parent = "pelvis"
+
+        component_containers = spine_inst.joint_mover.get_containers()
+        guide_nodes = component_containers[1].getNodeList()
+        utility_nodes = component_containers[2].getNodeList()
+        spine_inst.delete()
+
+        self.assertFalse(cmds.objExists("spine_metadata"))
+
+        for each in guide_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        for each in utility_nodes:
+            self.assertFalse(cmds.objExists(each.nodeName()))
+        self.assertEquals(joint_inst.parent, "root")
+
+    def test_bake_offsets(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+        spine_inst.joint_mover.aim_helper.toggle_aim_mode()
+        cmds.setAttr("spine_spine_02_mover_offset.translateY", 10)
+
+        pre_offset_position = format_position(cmds.xform("spine_spine_02_mover_offset", q=True, ws=True, t=True))
+        pre_main_position = format_position(cmds.xform("spine_spine_02_mover", q=True, ws=True, t=True))
+        pre_end_position = format_position(cmds.xform("spine_spine_03_mover", q=True, ws=True, t=True))
+
+        self.assertNotEquals(pre_main_position, pre_offset_position)
+
+        spine_inst.joint_mover.bake_offsets()
+
+        post_offset_position = format_position(cmds.xform("spine_spine_02_mover_offset", q=True, ws=True, t=True))
+        post_main_position = format_position(cmds.xform("spine_spine_02_mover", q=True, ws=True, t=True))
+        post_end_position = format_position(cmds.xform("spine_spine_03_mover", q=True, ws=True, t=True))
+
+        self.assertEquals(post_main_position, post_offset_position)
+        self.assertEquals(pre_end_position, post_end_position)
+
+    def test_pin_component(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+
+        pre_position = format_position(cmds.xform("spine_pelvis_mover", q=True, ws=True, t=True))
+        spine_inst.joint_mover.toggle_pin_component()
+        self.assertTrue(spine_inst.network_node.pinned.get())
+
+        cmds.setAttr("master_root_mover.translateX", 100)
+        post_position = format_position(cmds.xform("spine_pelvis_mover", q=True, ws=True, t=True))
+        self.assertEquals(pre_position, post_position)
+
+        spine_inst.joint_mover.toggle_pin_component()
+        cmds.setAttr("master_root_mover.translateX", 0)
+        new_position = format_position(cmds.xform("spine_pelvis_mover", q=True, ws=True, t=True))
+        self.assertNotEquals(post_position, new_position)
+
+    def test_aim_mode(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+        spine_inst.joint_mover.aim_helper.toggle_aim_mode()
+
+        self.assertEquals(spine_inst.network_node.isAiming.get(), True)
+        self.assertNotEquals(len(spine_inst.network_node.aimModeConstraints.connections()), 0)
+
+        original_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("spine_spine_02_mover.translateY", 10)
+        new_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertNotEquals(original_orientation, new_orientation)
+
+        spine_inst.joint_mover.aim_helper.toggle_aim_mode()
+        self.assertEquals(spine_inst.network_node.isAiming.get(), False)
+        self.assertEquals(len(spine_inst.network_node.aimModeConstraints.connections()), 0)
+
+        original_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)
+        cmds.setAttr("spine_spine_02_mover.translateY", 0)
+        new_orientation = cmds.xform("spine_spine_01_mover_offset", q=True, ws=True, ro=True)
+
+        self.assertEquals(original_orientation, new_orientation)
+
+    def test_duplicate(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+
+        cmds.setAttr("spine_pelvis_mover.translateY", -10)
+        cmds.setAttr("spine_pelvis_mover.rotateY", 30)
+        cmds.setAttr("spine_pelvis_mover.rotateZ", 42)
+        cmds.setAttr("spine_pelvis_mover.scaleY", 1.319)
+        cmds.setAttr("spine_pelvis_mover.scaleX", 1.319)
+        cmds.setAttr("spine_pelvis_mover.scaleZ", 1.319)
+        cmds.setAttr("spine_spine_01_mover.rotateZ", -25)
+
+        duplicate_inst = spine_inst.duplicate()
+
+        self.assertEquals(duplicate_inst.parent, "root")
+        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.ty"), cmds.getAttr("spine_pelvis_mover.ty"))
+        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.ry"), cmds.getAttr("spine_pelvis_mover.ry"))
+        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.rz"), cmds.getAttr("spine_pelvis_mover.rz"))
+        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.sx"), cmds.getAttr("spine_pelvis_mover.sx"))
+        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.sy"), cmds.getAttr("spine_pelvis_mover.sy"))
+        self.assertEquals(cmds.getAttr("spine_01_pelvis_mover.sz"), cmds.getAttr("spine_pelvis_mover.sz"))
+
+        self.assertEquals(cmds.getAttr("spine_01_spine_01_mover.rz"), cmds.getAttr("spine_spine_01_mover.rz"))
+        spine_inst.num_joints = 5
+        dupe2 = spine_inst.duplicate()
+        dupe3 = spine_inst.duplicate()
+        dupe4 = spine_inst.duplicate()
+        self.assertEquals(dupe2.suffix, "_02")
+        self.assertEquals(dupe3.suffix, "_03")
+        self.assertEquals(dupe4.suffix, "_04")
+
+    def test_invalid_property_values(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+
+        with self.assertRaises(RuntimeError):
+            spine_inst.num_joints = 6
+
+        with self.assertRaises(RuntimeError):
+            spine_inst.num_joints = 3.5
+
+        with self.assertRaises(RuntimeError):
+            spine_inst.num_joints = "3"
+
+        with self.assertRaises(RuntimeError):
+            spine_inst.num_joints = 0
+
+    def test_num_spine_bones(self):
+
+        self._create_asset()
+        spine_inst = self._create_spine_inst("")
+        spine_inst.num_joints = 4
+        joint_inst = joint.Joint()
+        joint_inst.parent = "spine_04"
+        spine_inst.num_joints = 3
+        self.assertEquals(joint_inst.parent, "root")
+        spine_inst.num_joints = 5
+        spine_inst.num_joints = 3
+        spine_inst.num_joints = 4
diff --git a/tests/test_utilities.py b/tests/test_utilities.py
new file mode 100644
index 0000000..33f0131
--- /dev/null
+++ b/tests/test_utilities.py
@@ -0,0 +1,147 @@
+import unittest
+import pymel.core as pm
+import artv2.components.base_components.rig_asset as rig_asset
+import artv2.components.root as root
+import artv2.components.biped_leg as leg
+import artv2.utilities.component_utilities as component_utils
+
+
+class Test_Module_Utils(unittest.TestCase):
+
+    @staticmethod
+    def _create_asset():
+        new_asset = rig_asset.RigAsset()
+        return new_asset
+
+    @staticmethod
+    def _create_some_components():
+        root.Root()
+        leg.BipedLeg(prefix="l")
+        leg.BipedLeg(prefix="r")
+
+    def test_get_rig_asset_node(self):
+
+        with self.assertRaises(StandardError):
+            component_utils.get_rig_asset_node()
+
+        asset = self._create_asset()
+        self._create_some_components()
+
+        character_node = component_utils.get_rig_asset_node()
+        self.assertEquals(character_node, asset.network_node)
+
+    def test_return_all_components(self):
+
+        self._create_asset()
+        self._create_some_components()
+
+        components = component_utils.return_all_components()
+        self.assertEquals(len(components), 3)
+
+    def test_get_top_level_mover(self):
+
+        self._create_asset()
+        leg_inst = leg.BipedLeg()
+
+        pynode = pm.PyNode(leg_inst.network_node.mover_grp.connections()[0])
+        top_mover = component_utils.get_top_level_mover(pynode)
+        self.assertEquals(top_mover.name(), "leg_thigh_mover")
+
+        leg_inst.prefix = "l"
+        top_mover = component_utils.get_top_level_mover(pynode)
+        self.assertEquals(top_mover.name(), "l_leg_thigh_mover")
+
+    def test_find_mover_from_joint(self):
+
+        self._create_asset()
+        leg_inst = leg.BipedLeg()
+
+        mover = component_utils.find_associated_mover_from_joint("thigh")
+        self.assertEquals(mover, "leg_thigh_mover")
+
+        leg_inst.suffix = "l"
+        mover = component_utils.find_associated_mover_from_joint("thigh_l")
+        self.assertEquals(mover, "leg_l_thigh_mover")
+
+    def test_get_all_created_joints(self):
+
+        self._create_asset()
+        self._create_some_components()
+
+        joints = component_utils.get_all_created_joints()
+        self.assertEquals(len(joints), 11)
+
+        new_inst = leg.BipedLeg(prefix="new")
+        new_inst.num_thigh_twists = 2
+
+        joints = component_utils.get_all_created_joints()
+        self.assertEquals(len(joints), 18)
+
+    def test_check_for_children(self):
+
+        self._create_asset()
+        root.Root()
+
+        l_leg_inst = leg.BipedLeg(prefix="l")
+        r_leg_inst = leg.BipedLeg(prefix="r")
+
+        l_leg_inst.num_thigh_twists = 2
+        r_leg_inst.parent = "l_thigh_twist_02"
+        l_leg_inst.num_thigh_twists = 1
+
+        self.assertEquals(r_leg_inst.parent, "root")
+
+    def test_validate_prefix(self):
+        self._create_asset()
+
+        leg_inst = leg.BipedLeg()
+
+        with self.assertRaises(StandardError):
+            leg_inst.prefix = "1"
+        with self.assertRaises(StandardError):
+            leg_inst.prefix = "x-man"
+
+        leg_inst.prefix = "l"
+
+        r_leg_inst = leg.BipedLeg()
+
+        with self.assertRaises(StandardError):
+            r_leg_inst.prefix = "l"
+
+        mover_grp = leg_inst.network_node.mover_grp.connections()[0]
+        child = mover_grp.getChildren()[0]
+        test_mover_name = child.nodeName()
+        self.assertEquals(test_mover_name, "l_leg_thigh_mover")
+
+        pynode = pm.PyNode("l_leg_thigh_mover_offset")
+        created_joint = pynode.created_joint.get()
+        self.assertEquals(created_joint,  "l_thigh")
+
+    def test_validate_suffix(self):
+        self._create_asset()
+
+        leg_inst = leg.BipedLeg()
+
+        with self.assertRaises(StandardError):
+            leg_inst.suffix = "x-man"
+
+        leg_inst.suffix = "l"
+
+        r_leg_inst = leg.BipedLeg()
+
+        with self.assertRaises(StandardError):
+            r_leg_inst.suffix = "l"
+
+        leg_inst.suffix = "l_01"
+        mover_grp = leg_inst.network_node.mover_grp.connections()[0]
+        child = mover_grp.getChildren()[0]
+        test_mover_name = child.nodeName()
+        self.assertEquals(test_mover_name, "leg_l_01_thigh_mover")
+
+        pynode = pm.PyNode("leg_l_01_thigh_mover_offset")
+        created_joint = pynode.created_joint.get()
+        self.assertEquals(created_joint,  "thigh_l_01")
+
+
+
+