diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
index f071518b42..a305b201d6 100644
--- a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
@@ -49,23 +49,18 @@ RenderableShapeEntityItem::Pointer RenderableShapeEntityItem::baseFactory(const
 }
 
 EntityItemPointer RenderableShapeEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
-    auto result = baseFactory(entityID, properties);
-
-    //TODO_CUSACK: Remove this before final PN
-    qCDebug(entities) << "Creating RenderableShapeEntityItem( " << result->_name << " ): " << result.get() << " ID: " << result->_id;
-
-    return result;
+    return baseFactory(entityID, properties);
 }
 
 EntityItemPointer RenderableShapeEntityItem::boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     auto result = baseFactory(entityID, properties);
-    result->setShape(entity::Shape::Cube);
+    result->setShape(entity::Cube);
     return result;
 }
 
 EntityItemPointer RenderableShapeEntityItem::sphereFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     auto result = baseFactory(entityID, properties);
-    result->setShape(entity::Shape::Sphere);
+    result->setShape(entity::Sphere);
     return result;
 }
 
@@ -90,19 +85,84 @@ bool RenderableShapeEntityItem::isTransparent() {
 
 void RenderableShapeEntityItem::computeShapeInfo(ShapeInfo& info) {
 
-    if (_collisionShapeType == ShapeType::SHAPE_TYPE_NONE) {
-        if (_shape == entity::Shape::NUM_SHAPES)
-        {
-            EntityItem::computeShapeInfo(info);
+    // This will be called whenever DIRTY_SHAPE flag (set by dimension change, etc)
+    // is set.
 
-            //--EARLY EXIT--( allow default handling to process )
-            return;
+    const glm::vec3 entityDimensions = getDimensions();
+
+    switch (_shape){
+    case entity::Shape::Quad:
+    case entity::Shape::Cube: {
+        _collisionShapeType = SHAPE_TYPE_BOX;
+    }
+    break;
+    case entity::Shape::Sphere: {
+
+        float diameter = entityDimensions.x;
+        const float MIN_DIAMETER = 0.001f;
+        const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
+        if (diameter > MIN_DIAMETER
+            && fabsf(diameter - entityDimensions.y) / diameter < MIN_RELATIVE_SPHERICAL_ERROR
+            && fabsf(diameter - entityDimensions.z) / diameter < MIN_RELATIVE_SPHERICAL_ERROR) {
+
+            _collisionShapeType = SHAPE_TYPE_SPHERE;
         }
+        else {
+            _collisionShapeType = SHAPE_TYPE_ELLIPSOID;
+        }
+    }
+    break;
+    case entity::Shape::Cylinder: {
+        _collisionShapeType = SHAPE_TYPE_CYLINDER_Y;
+        // TODO_CUSACK: determine if rotation is axis-aligned
+        //const Transform::Quat & rot = _transform.getRotation();
 
-        _collisionShapeType = ShapeFactory::computeShapeType(getShape(), getDimensions());
+#if 0
+        // TODO: some way to tell apart SHAPE_TYPE_CYLINDER_Y
+        // TODO_CUSACK: Should allow for minor variance along axes?
+        if ((entityDimensions.y >= entityDimensions.x) && (entityDimensions.y >= entityDimensions.z)) {
+        }
+        else if (entityDimensions.x >= entityDimensions.z) {
+            _collisionShapeType = SHAPE_TYPE_CYLINDER_X;
+        }
+        else if (entityDimensions.z >= entityDimensions.x) {
+            _collisionShapeType = SHAPE_TYPE_CYLINDER_Z;
+        }
+        else //...there was no major axis, treat as a hull
+        {
+            _collisionShapeType = SHAPE_TYPE_SIMPLE_HULL;
+            //TODO_CUSACK: pointCollection
+        }
+#endif
+    }
+    break;
+    case entity::Shape::Triangle:
+    case entity::Shape::Hexagon:
+    case entity::Shape::Octagon:
+    case entity::Shape::Circle:
+    case entity::Shape::Tetrahedron:
+    case entity::Shape::Octahedron:
+    case entity::Shape::Dodecahedron:
+    case entity::Shape::Icosahedron:
+    case entity::Shape::Cone: {
+        _collisionShapeType = SHAPE_TYPE_SIMPLE_HULL;
+        //TODO_CUSACK: pointCollection
+    }
+    break;
+    case entity::Shape::Torus:
+    {
+        // Not in GeometryCache::buildShapes, unsupported.
+        _collisionShapeType = SHAPE_TYPE_NONE;
+        //TODO_CUSACK: SHAPE_TYPE_SIMPLE_HULL and pointCollection (later)
+    }
+    break;
+    default:{
+        //_collisionShapeType = SHAPE_TYPE_NONE; // Remains SHAPE_TYPE_NONE.
+    }
+    break;
     }
 
-    return EntityItem::computeShapeInfo(info);
+    EntityItem::computeShapeInfo(info);
 }
 
 void RenderableShapeEntityItem::render(RenderArgs* args) {
diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.h b/libraries/entities-renderer/src/RenderableShapeEntityItem.h
index 96f450f523..2a841df57e 100644
--- a/libraries/entities-renderer/src/RenderableShapeEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.h
@@ -28,7 +28,7 @@ public:
 
     bool isTransparent() override;
 
-	void computeShapeInfo(ShapeInfo& info);
+    virtual void computeShapeInfo(ShapeInfo& info);
 
 private:
     std::unique_ptr<Procedural> _procedural { nullptr };
diff --git a/libraries/entities/CMakeLists.txt b/libraries/entities/CMakeLists.txt
index 84906a48df..19341ec3e2 100644
--- a/libraries/entities/CMakeLists.txt
+++ b/libraries/entities/CMakeLists.txt
@@ -1,4 +1,3 @@
 set(TARGET_NAME entities)
 setup_hifi_library(Network Script)
 link_hifi_libraries(shared networking octree avatars)
-
diff --git a/libraries/entities/src/ShapeEntityItem.cpp b/libraries/entities/src/ShapeEntityItem.cpp
index 854be7df1e..58799de807 100644
--- a/libraries/entities/src/ShapeEntityItem.cpp
+++ b/libraries/entities/src/ShapeEntityItem.cpp
@@ -58,12 +58,7 @@ ShapeEntityItem::Pointer ShapeEntityItem::baseFactory(const EntityItemID& entity
 }
 
 EntityItemPointer ShapeEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
-    auto result = baseFactory(entityID, properties);
-
-    //TODO_CUSACK: Remove this before final PN
-    qCDebug(entities) << "Creating ShapeEntityItem( " << result->_name << " ): " << result.get() << " ID: " << result->_id;
-
-    return result;
+    return baseFactory(entityID, properties);
 }
 
 EntityItemPointer ShapeEntityItem::boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
@@ -93,14 +88,14 @@ EntityItemProperties ShapeEntityItem::getProperties(EntityPropertyFlags desiredP
 
 void ShapeEntityItem::setShape(const entity::Shape& shape) {
     _shape = shape;
-    switch (_shape) {
+    switch (_shape) { // TODO_CUSACK fill out?
         case entity::Shape::Cube:
             _type = EntityTypes::Box;
             _collisionShapeType = ShapeType::SHAPE_TYPE_BOX;
             break;
         case entity::Shape::Sphere:
             _type = EntityTypes::Sphere;
-            _collisionShapeType = ShapeType::SHAPE_TYPE_ELLIPSOID;
+            _collisionShapeType = ShapeType::SHAPE_TYPE_ELLIPSOID; // TODO_CUSACK defer?  Check to see if sphere is more appropriate?
             break;
         default:
             _type = EntityTypes::Shape;
@@ -108,11 +103,6 @@ void ShapeEntityItem::setShape(const entity::Shape& shape) {
     }
 }
 
-//TODO_CUSACK: Move back to header prior to PN
-void ShapeEntityItem::setShape( const QString &shape ) {
-	setShape(entity::shapeFromString(shape));
-}
-
 bool ShapeEntityItem::setProperties(const EntityItemProperties& properties) {
     bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
 
@@ -175,25 +165,6 @@ void ShapeEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
 // This value specifes how the shape should be treated by physics calculations.  
 // For now, all polys will act as spheres
 ShapeType ShapeEntityItem::getShapeType() const {
-    //TODO_CUSACK: This needs to be retrieved from properties if possible
-    //		    or stored within a new member and set during parsing of
-    //			the properties like setShape via set/get/readEntityProperties.
-    //          Perhaps if the _actual_ collisionShapeType is needed (the version that's in use
-    //			based on analysis of the shape's halfExtents when BulletLibrary collision shape was
-    //          created as opposed to the desired ShapeType is it possible to retrieve that information)?
-    //if (_shape == entity::Shape::Cylinder) {
-    //  return SHAPE_TYPE_CYLINDER_Y;
-    //}
-
-    //// Original functionality:  Everything not a cube, is treated like an ellipsoid/sphere
-    //return (_shape == entity::Shape::Cube) ? SHAPE_TYPE_BOX : SHAPE_TYPE_ELLIPSOID;
-
-    //if (_collisionShapeType == ShapeType::SHAPE_TYPE_NONE)
-    //{
-    //  //--EARLY EXIT--( Maintain previous behavior of treating invalid as Ellipsoid/Sphere )
-    //  return SHAPE_TYPE_ELLIPSOID;
-    //}
-
     return _collisionShapeType;
 }
 
@@ -254,7 +225,7 @@ bool ShapeEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const
 void ShapeEntityItem::debugDump() const {
     quint64 now = usecTimestampNow();
     qCDebug(entities) << "SHAPE EntityItem id:" << getEntityItemID() << "---------------------------------------------";
-	qCDebug(entities) << "               name:" << _name;
+    qCDebug(entities) << "               name:" << _name;
     qCDebug(entities) << "              shape:" << stringFromShape(_shape) << " (EnumId: " << _shape << " )";
     qCDebug(entities) << "              color:" << _color[0] << "," << _color[1] << "," << _color[2];
     qCDebug(entities) << "           position:" << debugTreeVector(getPosition());
diff --git a/libraries/entities/src/ShapeEntityItem.h b/libraries/entities/src/ShapeEntityItem.h
index 435d22a6b2..42a92f7bd7 100644
--- a/libraries/entities/src/ShapeEntityItem.h
+++ b/libraries/entities/src/ShapeEntityItem.h
@@ -70,7 +70,7 @@ public:
 
     entity::Shape getShape() const { return _shape; }
     void setShape(const entity::Shape& shape);
-	void setShape(const QString& shape);
+    void setShape(const QString& shape) { setShape(entity::shapeFromString(shape)); }
 
     float getAlpha() const { return _alpha; };
     void setAlpha(float alpha) { _alpha = alpha; }
@@ -100,7 +100,7 @@ protected:
     float _alpha { 1 };
     rgbColor _color;
     entity::Shape _shape { entity::Shape::Sphere };
-	ShapeType _collisionShapeType{ ShapeType::SHAPE_TYPE_NONE };
+    ShapeType _collisionShapeType { ShapeType::SHAPE_TYPE_NONE };
 };
 
 #endif // hifi_ShapeEntityItem_h
diff --git a/libraries/physics/src/ShapeFactory.cpp b/libraries/physics/src/ShapeFactory.cpp
index 74aff45e55..87580c6726 100644
--- a/libraries/physics/src/ShapeFactory.cpp
+++ b/libraries/physics/src/ShapeFactory.cpp
@@ -247,123 +247,6 @@ void deleteStaticMeshArray(btTriangleIndexVertexArray* dataArray) {
     delete dataArray;
 }
 
-ShapeType validateShapeType(ShapeType type, const glm::vec3 &halfExtents, btCollisionShape **outCollisionShape = NULL)
-{
-    if ((type == SHAPE_TYPE_SPHERE) || (type == SHAPE_TYPE_ELLIPSOID))
-    {
-        float radius = halfExtents.x;
-        const float MIN_RADIUS = 0.001f;
-        const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
-        if (radius > MIN_RADIUS
-            && fabsf(radius - halfExtents.y) / radius < MIN_RELATIVE_SPHERICAL_ERROR
-            && fabsf(radius - halfExtents.z) / radius < MIN_RELATIVE_SPHERICAL_ERROR) {
-            // close enough to true sphere
-            if (outCollisionShape) {
-                (*outCollisionShape) = new btSphereShape(radius);
-            }
-
-            return SHAPE_TYPE_SPHERE;
-        }
-        else {
-            ShapeInfo::PointList points;
-            points.reserve(NUM_UNIT_SPHERE_DIRECTIONS);
-            for (uint32_t i = 0; i < NUM_UNIT_SPHERE_DIRECTIONS; ++i) {
-                points.push_back(bulletToGLM(_unitSphereDirections[i]) * halfExtents);
-            }
-            if (outCollisionShape) {
-                (*outCollisionShape) = createConvexHull(points);
-            }
-
-            return SHAPE_TYPE_ELLIPSOID;
-        }
-    }
-    else if ((type == SHAPE_TYPE_CYLINDER_X) || (type == SHAPE_TYPE_CYLINDER_Y) || (type == SHAPE_TYPE_CYLINDER_Z))
-    {
-        // TODO_CUSACK: Should allow for minor variance along axes?
-        const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
-        if ((halfExtents.y >= halfExtents.x) && (halfExtents.y >= halfExtents.z)) {
-            if (outCollisionShape) {
-                (*outCollisionShape) = new btCylinderShape(btHalfExtents);
-            }
-
-            return SHAPE_TYPE_CYLINDER_Y;
-        }
-        else if (halfExtents.x >= halfExtents.z) {
-            if (outCollisionShape) {
-                (*outCollisionShape) = new btCylinderShapeX(btHalfExtents);
-            }
-
-            return SHAPE_TYPE_CYLINDER_X;
-        }
-        else if (halfExtents.z > halfExtents.x) {
-            if (outCollisionShape) {
-                (*outCollisionShape) = new btCylinderShapeZ(btHalfExtents);
-            }
-
-            return SHAPE_TYPE_CYLINDER_Z;
-        }
-        else //...there was no major axis, treat as a sphere
-        {
-            ShapeType cylinderFallback = validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents, outCollisionShape);
-            return cylinderFallback;
-        }
-    }
-
-    //Got here, then you are what you are along with outCollisionShape
-    return type;
-}
-
-ShapeType ShapeFactory::computeShapeType(entity::Shape shape, const glm::vec3 &entityDimensions) {
-    if (shape == entity::Shape::NUM_SHAPES) {
-        //--EARLY EXIT--
-        return SHAPE_TYPE_NONE;
-    }
-
-    const glm::vec3 halfExtents = entityDimensions * 0.5f;
-    switch (shape){
-    case entity::Shape::Triangle: {
-        //TODO_CUSACK: Implement this
-        return validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents);
-    }
-    //Note: Intentional Fallthrough from Quad to Cube
-    case entity::Shape::Quad:
-    case entity::Shape::Cube: {
-        return SHAPE_TYPE_BOX;
-    }
-    //Note: Intentional Fallthrough from Hexagon to Sphere
-    case entity::Shape::Hexagon:
-    case entity::Shape::Octagon:
-    case entity::Shape::Circle:
-    case entity::Shape::Sphere: {
-        return validateShapeType(SHAPE_TYPE_SPHERE, halfExtents);
-    }
-
-    case entity::Shape::Cylinder: {
-        return validateShapeType(SHAPE_TYPE_CYLINDER_Y, halfExtents);
-    }
-
-    //Note: Intentional Fallthrough from Tetrahedron to Icosahedron
-    case entity::Shape::Tetrahedron:
-    case entity::Shape::Octahedron:
-    case entity::Shape::Dodecahedron:
-    case entity::Shape::Icosahedron: {
-
-        //TODO_CUSACK: Implement the hedrons
-        return validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents);
-    }
-
-    //Note:  Intentional Fallthrough from Torus to default.
-    case entity::Shape::Torus:
-    case entity::Shape::Cone: {
-
-        // These types are currently unsupported
-    }
-    default:
-        return SHAPE_TYPE_NONE;
-    }
-
-}
-
 const btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info) {
     btCollisionShape* shape = NULL;
     int type = info.getType();
@@ -372,37 +255,32 @@ const btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info)
             shape = new btBoxShape(glmToBullet(info.getHalfExtents()));
         }
         break;
-        //case SHAPE_TYPE_SPHERE: {
-        //    glm::vec3 halfExtents = info.getHalfExtents();
-        //    float radius = glm::max(halfExtents.x, glm::max(halfExtents.y, halfExtents.z));
-        //    shape = new btSphereShape(radius);
-        //}
-        //break;
-        case SHAPE_TYPE_SPHERE:
-        case SHAPE_TYPE_ELLIPSOID: {
+        case SHAPE_TYPE_SPHERE: {
             glm::vec3 halfExtents = info.getHalfExtents();
-            //float radius = halfExtents.x;
-            //const float MIN_RADIUS = 0.001f;
-            //const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
-            //if (radius > MIN_RADIUS
-            //        && fabsf(radius - halfExtents.y) / radius < MIN_RELATIVE_SPHERICAL_ERROR
-            //        && fabsf(radius - halfExtents.z) / radius < MIN_RELATIVE_SPHERICAL_ERROR) {
-            //    // close enough to true sphere
-            //    shape = new btSphereShape(radius);
-            //} else {
-            //    ShapeInfo::PointList points;
-            //    points.reserve(NUM_UNIT_SPHERE_DIRECTIONS);
-            //    for (uint32_t i = 0; i < NUM_UNIT_SPHERE_DIRECTIONS; ++i) {
-            //        points.push_back(bulletToGLM(_unitSphereDirections[i]) * halfExtents);
-            //    }
-            //    shape = createConvexHull(points);
-            //}
-
-            validateShapeType(SHAPE_TYPE_ELLIPSOID, halfExtents, &shape);
+            float radius = glm::max(halfExtents.x, glm::max(halfExtents.y, halfExtents.z));
+            shape = new btSphereShape(radius);
+        }
+        break;
+        case SHAPE_TYPE_ELLIPSOID: {
+            glm::vec3 halfExtents = info.getHalfExtents();
+            float radius = halfExtents.x;
+            const float MIN_RADIUS = 0.001f;
+            const float MIN_RELATIVE_SPHERICAL_ERROR = 0.001f;
+            if (radius > MIN_RADIUS
+                    && fabsf(radius - halfExtents.y) / radius < MIN_RELATIVE_SPHERICAL_ERROR
+                    && fabsf(radius - halfExtents.z) / radius < MIN_RELATIVE_SPHERICAL_ERROR) {
+                // close enough to true sphere
+                shape = new btSphereShape(radius);
+            } else {
+                ShapeInfo::PointList points;
+                points.reserve(NUM_UNIT_SPHERE_DIRECTIONS);
+                for (uint32_t i = 0; i < NUM_UNIT_SPHERE_DIRECTIONS; ++i) {
+                    points.push_back(bulletToGLM(_unitSphereDirections[i]) * halfExtents);
+                }
+                shape = createConvexHull(points);
+            }
         }
         break;
-        //TODO_CUSACK: Add Capsules to vetting/validation process for
-        //             type checks.
         case SHAPE_TYPE_CAPSULE_Y: {
             glm::vec3 halfExtents = info.getHalfExtents();
             float radius = halfExtents.x;
@@ -424,30 +302,22 @@ const btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info)
             shape = new btCapsuleShapeZ(radius, height);
         }
         break;
-        case SHAPE_TYPE_CYLINDER_X:
-        case SHAPE_TYPE_CYLINDER_Z:
-        case SHAPE_TYPE_CYLINDER_Y: {
-            // TODO_CUSACK: Should allow for minor variance along axes.
+        case SHAPE_TYPE_CYLINDER_X: {
             const glm::vec3 halfExtents = info.getHalfExtents();
-            //const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
-            //if ((halfExtents.y > halfExtents.x) && (halfExtents.y > halfExtents.z)) {
-            //  shape = new btCylinderShape(btHalfExtents);
-            //}
-            //else if (halfExtents.x > halfExtents.z) {
-            //  shape = new btCylinderShapeX(btHalfExtents);
-            //}
-            //else if (halfExtents.z > halfExtents.x) {
-            //  shape = new btCylinderShapeZ(btHalfExtents);
-            //}
-            //else //...there was no major axis, treat as a sphere
-            //{
-            //  //TODO_CUSACK: Shunt to ELLIPSOID handling
-            //}
-            validateShapeType(SHAPE_TYPE_CYLINDER_Y, halfExtents, &shape);
+            const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
+            shape = new btCylinderShapeX(btHalfExtents);
+        }
+        case SHAPE_TYPE_CYLINDER_Z: {
+            const glm::vec3 halfExtents = info.getHalfExtents();
+            const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
+            shape = new btCylinderShapeZ(btHalfExtents);
+        }
+        case SHAPE_TYPE_CYLINDER_Y: {
+            const glm::vec3 halfExtents = info.getHalfExtents();
+            const btVector3 btHalfExtents(halfExtents.x, halfExtents.y, halfExtents.z);
+            shape = new btCylinderShape(btHalfExtents);
         }
         break;
-        //TODO_CUSACK: Add compound and simple hull to vetting/validation
-        //             process for types.
         case SHAPE_TYPE_COMPOUND:
         case SHAPE_TYPE_SIMPLE_HULL: {
             const ShapeInfo::PointCollection& pointCollection = info.getPointCollection();
diff --git a/libraries/physics/src/ShapeFactory.h b/libraries/physics/src/ShapeFactory.h
index 52b448ee1d..2bf79f390c 100644
--- a/libraries/physics/src/ShapeFactory.h
+++ b/libraries/physics/src/ShapeFactory.h
@@ -15,14 +15,11 @@
 #include <btBulletDynamicsCommon.h>
 #include <glm/glm.hpp>
 
-#include <ShapeEntityItem.h> //< Needed for entity::Shape
 #include <ShapeInfo.h>
 
 // translates between ShapeInfo and btShape
 
 namespace ShapeFactory {
-
-	ShapeType computeShapeType( entity::Shape shape, const glm::vec3 &entityDimensions);
     const btCollisionShape* createShapeFromInfo(const ShapeInfo& info);
     void deleteShape(const btCollisionShape* shape);
 
diff --git a/libraries/shared/src/ShapeInfo.cpp b/libraries/shared/src/ShapeInfo.cpp
index 57e927eaf3..5d6b4ece7a 100644
--- a/libraries/shared/src/ShapeInfo.cpp
+++ b/libraries/shared/src/ShapeInfo.cpp
@@ -29,8 +29,8 @@ void ShapeInfo::clear() {
 }
 
 void ShapeInfo::setParams(ShapeType type, const glm::vec3& halfExtents, QString url) {
-	//TODO_CUSACK: Does this need additional cases and handling added?
-	_url = "";
+    //TODO_CUSACK: Does this need additional cases and handling added?
+    _url = "";
     _type = type;
     setHalfExtents(halfExtents);
     switch(type) {
diff --git a/scripts/developer/tests/basicEntityTest/entitySpawner.js b/scripts/developer/tests/basicEntityTest/entitySpawner.js
index fa5c9291cb..538e9145f5 100644
--- a/scripts/developer/tests/basicEntityTest/entitySpawner.js
+++ b/scripts/developer/tests/basicEntityTest/entitySpawner.js
@@ -8,9 +8,7 @@
   var SCRIPT_URL = Script.resolvePath("myEntityScript.js")
 
   var myEntity = Entities.addEntity({
-      name: "Cusack_Testing",
-      type: "Shape",
-      shapeType: "Cylinder",
+      type: "Sphere",
       color: {
           red: 200,
           green: 10,