Ability to use existing data

src/Builder.php

@@ -139,6 +139,43 @@ protected function persist($name, array $attributes = [])
         return $entity;
     }
 
+    /**
+     * Fetch a random existing entity, or create a new one
+     *
+     * @param $name
+     * @param $overrides
+     * @param array $existingKeys
+     * @return mixed
+     * @throws TestDummyException
+     */
+    protected function random($name, $overrides, array $existingKeys = [])
+    {
+        $attributes = $this->getAttributes($name, $overrides);
+        $class = $this->getFixture($name)->name;
+
+        // We'll pass off the process of creating the entity.
+        // That way, folks can use different persistence layers.
+
+        return $this->model->random($class, $attributes, $existingKeys);
+    }
+
+    /**
+     * Assign relationships to a randomly fetched entity
+     * @param $name
+     * @param $attributes
+     * @param array $existingKeys
+     * @return mixed
+     */
+    public function exists($name, $attributes, array $existingKeys = [])
+    {
+        $entity = $this->random($name, $attributes, $existingKeys);
+
+        $this->assignRelationships($entity, $attributes);
+        $this->model->save($entity);
+
+        return $entity;
+    }
+
     /**
      * Merge the fixture with any potential overrides.
      *
@@ -282,12 +319,14 @@ protected function assignRelationships($entity, $attributes)
         // to see if there are any defined relationships. If there
         // are, then we'll need to create those records as well.
 
+        $existing = [];
+
         foreach ($modelAttributes as $columnName => $value) {
             if ($relationship = $this->findRelation($value)) {
-                $entity[$columnName] = $this->fetchRelationId($relationship, $columnName, $attributes);
+                // $relationship is now our $matches array from findRelation
+                $existing[] = $entity[$columnName] = $this->fetchRelationId($relationship, $columnName, $attributes, $existing);
             }
         }
-
         return $entity;
     }
 
@@ -299,8 +338,8 @@ protected function assignRelationships($entity, $attributes)
      */
     protected function findRelation($attribute)
     {
-        if (is_string($attribute) && preg_match('/^factory:(.+)$/i', $attribute, $matches)) {
-            return $matches[1];
+        if (is_string($attribute) && (preg_match('/^factory:(.+)$/i', $attribute, $matches) || preg_match('/^model:(.+)$/i', $attribute, $matches))) {
+            return $matches;
         }
 
         return false;
@@ -312,12 +351,26 @@ protected function findRelation($attribute)
      * @param  string $factoryName
      * @param  string $relationshipName
      * @param  array  $attributes
+     * @param  array  $existingKeys
      * @return int
+     * @throws \Exception
      */
-    protected function fetchRelationId($factoryName, $relationshipName, array $attributes)
+    protected function fetchRelationId($factoryName, $relationshipName, array $attributes, array $existingKeys)
     {
-        $attributes = $this->extractRelationshipAttributes($relationshipName, $attributes);
-        $relationKey = $this->persist($factoryName, $attributes)->getKey();
+        // $factoryName is our matches, containing both 'model:factoryName'/'factory:factoryName' and just the factoryName
+        $type = preg_replace('/' . $factoryName[1] . '/', '', $factoryName[0]);
+        switch ($type) {
+            case 'factory:':
+                $attributes = $this->extractRelationshipAttributes($relationshipName, $attributes);
+                $relationKey = $this->persist($factoryName[1], $attributes)->getKey();
+                break;
+            case 'model:':
+                $attributes = $this->extractRelationshipAttributes($relationshipName, $attributes);
+                $relationKey = $this->exists($factoryName[1], $attributes, $existingKeys)->getKey();
+                break;
+            default:
+                throw new \Exception('Relation identifier not allowed. Please use model or factory.');
+        }
 
         return $relationKey;
     }

src/EloquentModel.php

@@ -24,6 +24,30 @@ public function build($type, array $attributes)
         return $this->fill($type, $attributes);
     }
 
+
+    /**
+     * Get a random entity and fill any override attributes
+     * @param $type
+     * @param array $attributes
+     * @param array $existingKeys
+     * @return mixed
+     * @throws TestDummyException
+     */
+    public function random($type, array $attributes, array $existingKeys)
+    {
+        if ( ! class_exists($type)) {
+            throw new TestDummyException("The {$type} model was not found.");
+        }
+
+        $model = $this->getRandom($type, $existingKeys);
+
+        Eloquent::unguard();
+        $model->fill($attributes);
+        Eloquent::reguard();
+
+        return $model;
+    }
+
     /**
      * Persist the entity.
      *
@@ -64,4 +88,23 @@ private function fill($type, $attributes)
         return $object;
     }
 
+    /**
+     * Fetch a random entity from the database which is not already in use
+     * If none exists, create a new one
+     *
+     * @param $type
+     * @param array $existingKeys
+     * @return mixed
+     */
+    private function getRandom($type, array $existingKeys)
+    {
+        $object = new $type;
+        $count = $type::count() - count($existingKeys);
+        if ($count > 0) {
+            $rand = mt_rand(0,$count-1);
+            return $object->whereNotIn($object->getKeyName(), $existingKeys)->get()[$rand];
+        }
+        return $object;
+    }
+
 }

src/IsPersistable.php

@@ -31,4 +31,6 @@ public function save($entity);
      */
     public function getAttributes($entity);
 
+    public function random($type, array $attributes, array $existingKeys);
+
 }