Apply conditions/scopes to related model query

composer.json

@@ -88,7 +88,8 @@
     },
     "autoload-dev": {
         "classmap": [
-            "tests/TestCase.php"
+            "tests/TestCase.php",
+            "tests/DbTestCase.php"
         ]
     },
     "scripts": {

src/Database/Relations/BelongsToMany.php

@@ -164,7 +164,7 @@ public function detach($ids = null, $touch = true)
     {
         $attachedIdList = $this->parseIds($ids);
         if (empty($attachedIdList)) {
-            $attachedIdList = $this->newPivotQuery()->lists($this->relatedPivotKey);
+            $attachedIdList = $this->allRelatedIds()->all();
         }
 
         /**
@@ -188,7 +188,7 @@ public function detach($ids = null, $touch = true)
         /*
          * See Illuminate\Database\Eloquent\Relations\Concerns\InteractsWithPivotTable
          */
-        parent::detach($ids, $touch);
+        parent::detach($attachedIdList, $touch);
 
         /**
          * @event model.relation.afterDetach
@@ -406,7 +406,17 @@ public function getOtherKey()
      */
     public function getRelatedIds($sessionKey = null)
     {
-        traceLog('Method BelongsToMany::allRelatedIds has been deprecated, use BelongsToMany::allRelatedIds instead.');
+        traceLog('Method BelongsToMany::getRelatedIds has been deprecated, use BelongsToMany::allRelatedIds instead.');
         return $this->allRelatedIds($sessionKey)->all();
     }
+
+    /**
+     * Get the pivot models that are currently attached (taking conditions & scopes into account).
+     *
+     * @return \Illuminate\Support\Collection
+     */
+    protected function getCurrentlyAttachedPivots()
+    {
+        return $this->getQuery()->get();
+    }
 }

tests/Database/RelationsTest.php

@@ -0,0 +1,161 @@
+<?php
+
+class RelationsTest extends DbTestCase
+{
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        $this->createTables();
+        $this->seedTables();
+    }
+
+    public function createTables()
+    {
+        $this->db->schema()->create('posts', function ($table) {
+            $table->increments('id');
+            $table->string('title')->default('');
+            $table->timestamps();
+        });
+
+        $this->db->schema()->create('terms', function ($table) {
+            $table->increments('id');
+            $table->string('type');
+            $table->string('name');
+            $table->timestamps();
+        });
+
+        $this->db->schema()->create('posts_terms', function ($table) {
+            $table->increments('id');
+            $table->unsignedInteger('post_id');
+            $table->unsignedInteger('term_id');
+        });
+    }
+
+    public function seedTables()
+    {
+        $post = Post::create([
+            'title' => 'A Post',
+        ]);
+
+        $post->tags()->create(['type'=>'tag', 'name'=>'A Tag']);
+        $post->tags()->create(['type'=>'tag', 'name'=>'Second Tag']);
+        $post->categories()->create(['type'=>'category', 'name'=>'A Category']);
+        $post->categories()->create(['type'=>'category', 'name'=>'Second Category']);
+    }
+
+    public function testTablesExist()
+    {
+        $this->assertTrue($this->db->schema()->hasTable('posts'));
+        $this->assertTrue($this->db->schema()->hasTable('terms'));
+        $this->assertTrue($this->db->schema()->hasTable('posts_terms'));
+    }
+
+    public function testTablesProperlySeeded()
+    {
+        $this->assertEquals(1, Post::count());
+        $this->assertEquals(4, Term::count());
+        $this->assertEquals(2, Term::where('type', 'tag')->count());
+        $this->assertEquals(2, Term::where('type', 'category')->count());
+    }
+
+    public function testBelongsToManyCount()
+    {
+        $post = Post::first();
+        $this->assertEquals(2, $post->tags->count());
+        $this->assertEquals(2, $post->categories->count());
+    }
+
+    public function testBelongsToManySyncAll()
+    {
+        $post = Post::first();
+
+        $id = $post->categories()->first()->id;
+        $post->categories()->sync([$id]);
+        $this->assertEquals(1, $post->categories->count());
+        $this->assertEquals($id, $post->categories()->first()->id);
+
+        $id = $post->tags()->first()->id;
+        $post->tags()->sync([$id]);
+        $this->assertEquals(1, $post->tags->count());
+        $this->assertEquals($id, $post->tags()->first()->id);
+    }
+
+    public function testBelongsToManySyncTags()
+    {
+        $post = Post::first();
+
+        $post->categories()->detach();
+        $this->assertEquals(0, $post->categories->count());
+
+        $id = $post->tags()->first()->id;
+        $post->tags()->sync([$id]);
+        $this->assertEquals(1, $post->tags->count());
+        $this->assertEquals($id, $post->tags()->first()->id);
+    }
+
+    public function testBelongsToManySyncCategories()
+    {
+        $post = Post::first();
+
+        $id = $post->categories()->first()->id;
+        $post->categories()->sync([$id]);
+        $this->assertEquals(1, $post->categories->count());
+        $this->assertEquals($id, $post->categories()->first()->id);
+
+        $post->tags()->detach();
+        $this->assertEquals(0, $post->tags->count());
+    }
+
+    public function testBelongsToManyDetach()
+    {
+        $post = Post::first();
+
+        $post->categories()->detach();
+        $this->assertEquals(0, $post->categories->count());
+
+        $post->tags()->detach();
+        $this->assertEquals(0, $post->tags->count());
+    }
+}
+
+class Post extends \October\Rain\Database\Model
+{
+    public $table = 'posts';
+
+    public $fillable = ['title'];
+
+    public $belongsToMany = [
+        'tags' => [
+            Term::class,
+            'table'     => 'posts_terms',
+            'key'       => 'post_id',
+            'otherKey'  => 'term_id',
+            'conditions' => 'type = "tag"'
+        ],
+        'categories' => [
+            Term::class,
+            'table'     => 'posts_terms',
+            'key'       => 'post_id',
+            'otherKey'  => 'term_id',
+            'conditions' => 'type = "category"'
+        ],
+    ];
+}
+
+class Term extends \October\Rain\Database\Model
+{
+    public $table = 'terms';
+
+    public $fillable = ['type', 'name'];
+
+    public $belongsToMany = [
+        'posts' => [
+            'Post',
+            'table'      => 'posts_terms',
+            'key'        => 'term_id',
+            'otherKey'   => 'post_id',
+            'conditions' => 'type = "post"'
+        ],
+    ];
+}

tests/Database/Traits/EncryptableTest.php

@@ -2,7 +2,7 @@
 
 use Illuminate\Encryption\Encrypter;
 
-class EncryptableTest extends TestCase
+class EncryptableTest extends DbTestCase
 {
     const TEST_CRYPT_KEY = 'gBmM1S5bxZ5ePRj5';
 
@@ -13,17 +13,9 @@ class EncryptableTest extends TestCase
 
     public function setUp(): void
     {
-        $capsule = new Illuminate\Database\Capsule\Manager;
-        $capsule->addConnection([
-            'driver'   => 'sqlite',
-            'database' => ':memory:',
-            'prefix'   => ''
-        ]);
+        parent::setUp();
 
-        $capsule->setAsGlobal();
-        $capsule->bootEloquent();
-
-        $capsule->schema()->create('secrets', function ($table) {
+        $this->db->schema()->create('secrets', function ($table) {
             $table->increments('id');
             $table->string('secret');
             $table->timestamps();

tests/DbTestCase.php

@@ -0,0 +1,56 @@
+<?php
+
+use October\Rain\Database\Model;
+use October\Rain\Database\Pivot;
+use Illuminate\Database\Capsule\Manager as CapsuleManager;
+
+class DbTestCase extends TestCase
+{
+    public function setUp(): void
+    {
+        $this->db = new CapsuleManager;
+        $this->db->addConnection([
+            'driver'   => 'sqlite',
+            'database' => ':memory:',
+            'prefix'   => ''
+        ]);
+
+        $this->db->setAsGlobal();
+        $this->db->bootEloquent();
+    }
+
+    public function tearDown() : void
+    {
+        $this->flushModelEventListeners();
+        parent::tearDown();
+        unset($this->db);
+    }
+
+    /**
+     * The models in October use a static property to store their events, these
+     * will need to be targeted and reset ready for a new test cycle.
+     * Pivot models are an exception since they are internally managed.
+     * @return void
+     */
+    protected function flushModelEventListeners()
+    {
+        foreach (get_declared_classes() as $class) {
+            if ($class === Pivot::class) {
+                continue;
+            }
+
+            $reflectClass = new ReflectionClass($class);
+            if (
+                !$reflectClass->isInstantiable() ||
+                !$reflectClass->isSubclassOf(Model::class) ||
+                $reflectClass->isSubclassOf(Pivot::class)
+            ) {
+                continue;
+            }
+
+            $class::flushEventListeners();
+        }
+
+        Model::flushEventListeners();
+    }
+}