Fix isEmpty returning true if $id is not selected

src/Database/Database.php

@@ -2238,12 +2238,13 @@ public function getDocument(string $collection, string $id, array $queries = [])
         }
 
         $document = $this->adapter->getDocument($collection->getId(), $id, $queries);
-        $document->setAttribute('$collection', $collection->getId());
 
         if ($document->isEmpty()) {
             return $document;
         }
 
+        $document->setAttribute('$collection', $collection->getId());
+
         if ($collection->getId() !== self::METADATA) {
             if (!$validator->isValid([
                 ...$collection->getRead(),
@@ -4072,7 +4073,10 @@ public function find(string $collection, array $queries = [], ?int $timeout = nu
             }
             $node = $this->casting($collection, $node);
             $node = $this->decode($collection, $node, $selections);
-            $node->setAttribute('$collection', $collection->getId());
+
+            if (!$node->isEmpty()) {
+                $node->setAttribute('$collection', $collection->getId());
+            }
         }
 
         $results = $this->applyNestedQueries($results, $nestedQueries, $relationships);

src/Database/Document.php

@@ -371,7 +371,7 @@ public function findAndRemove(string $key, $find, string $subject = ''): bool
      */
     public function isEmpty(): bool
     {
-        return empty($this->getId());
+        return !\count($this);
     }
 
     /**

tests/Database/Adapter/MariaDBTest.php

@@ -58,9 +58,4 @@ public static function getDatabase(): Database
 
         return self::$database = $database;
     }
-
-    public static function killDatabase(): void
-    {
-        self::$database = null;
-    }
 }

tests/Database/Adapter/MongoDBTest.php

@@ -95,9 +95,4 @@ public function testKeywords(): void
     {
         $this->assertTrue(true);
     }
-
-    public static function killDatabase(): void
-    {
-        self::$database = null;
-    }
 }

tests/Database/Adapter/MySQLTest.php

@@ -69,9 +69,4 @@ public static function getDatabase(): Database
 
         return self::$database = $database;
     }
-
-    public static function killDatabase(): void
-    {
-        self::$database = null;
-    }
 }

tests/Database/Adapter/PostgresTest.php

@@ -56,9 +56,4 @@ public static function getDatabase(): Database
 
         return self::$database = $database;
     }
-
-    public static function killDatabase(): void
-    {
-        self::$database = null;
-    }
 }

tests/Database/Adapter/SQLiteTest.php

@@ -66,9 +66,4 @@ public static function getDatabase(): Database
 
         return self::$database = $database;
     }
-
-    public static function killDatabase(): void
-    {
-        self::$database = null;
-    }
 }

tests/Database/Base.php

@@ -35,8 +35,6 @@ abstract class Base extends TestCase
      */
     abstract protected static function getDatabase(): Database;
 
-    abstract protected static function killDatabase(): void;
-
     /**
      * @return string
      */
@@ -1056,7 +1054,8 @@ public function testGetDocumentSelect(Document $document): Document
             Query::select(['string', 'integer']),
         ]);
 
-        $this->assertNotEmpty(true, $document->getId());
+        $this->assertEmpty($document->getId());
+        $this->assertFalse($document->isEmpty());
         $this->assertIsString($document->getAttribute('string'));
         $this->assertEquals('text📝', $document->getAttribute('string'));
         $this->assertIsInt($document->getAttribute('integer'));
@@ -11691,6 +11690,89 @@ public function testLabels(): void
         $this->assertCount(1, $documents);
     }
 
+    public function testEmptyOperatorValues(): void
+    {
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::equal('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Equal queries require at least one value.', $e->getMessage());
+        }
+
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::search('string', null),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
+        }
+
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::notEqual('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
+        }
+
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::lessThan('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
+        }
+
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::lessThanEqual('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
+        }
+
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::greaterThan('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
+        }
+
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::greaterThanEqual('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
+        }
+
+        try {
+            static::getDatabase()->findOne('documents', [
+                Query::contains('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(Exception::class, $e);
+            $this->assertEquals('Invalid query: Contains queries require at least one value.', $e->getMessage());
+        }
+    }
+
     public function testEvents(): void
     {
         Authorization::skip(function () {
@@ -11782,93 +11864,4 @@ public function testEvents(): void
             $database->delete('hellodb');
         });
     }
-
-    public function testEmptyOperatorValues(): void
-    {
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::equal('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Equal queries require at least one value.', $e->getMessage());
-        }
-
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::search('string', null),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
-        }
-
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::notEqual('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
-        }
-
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::lessThan('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
-        }
-
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::lessThanEqual('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
-        }
-
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::greaterThan('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
-        }
-
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::greaterThanEqual('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Query type does not match expected: string', $e->getMessage());
-        }
-
-        try {
-            static::getDatabase()->findOne('documents', [
-                Query::contains('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Contains queries require at least one value.', $e->getMessage());
-        }
-    }
-
-    public function testLast(): void
-    {
-        $this->expectNotToPerformAssertions();
-        static::killDatabase();
-    }
 }