diff --git a/packages/utopia_database/test/query_test.dart b/packages/utopia_database/test/query_test.dart
new file mode 100644
index 0000000..c2f5aca
--- /dev/null
+++ b/packages/utopia_database/test/query_test.dart
@@ -0,0 +1,211 @@
+import 'package:test/test.dart';
+import 'package:utopia_database/utopia_database.dart';
+
+void main() {
+  group('Query Class Tests', () {
+    test('Query Creation and Method Checks', () {
+      // Test creation with TYPE_ORDER_ASC
+      var query = Query(Query.typeOrderAsc, attribute: 'score');
+      expect(query.method, equals(Query.typeOrderAsc));
+      expect(query.attribute, equals('score'));
+      expect(query.values, isEmpty);
+
+      // Test creation with TYPE_IS_NULL
+      query = Query.isNull('title');
+      expect(query.method, equals(Query.typeIsNull));
+      expect(query.attribute, equals('title'));
+      expect(query.values, isEmpty);
+
+      // Test creation with TYPE_IS_NOT_NULL
+      query = Query.isNotNull('title');
+      expect(query.method, equals(Query.typeIsNotNull));
+      expect(query.attribute, equals('title'));
+      expect(query.values, isEmpty);
+
+      // Test creation with TYPE_CONTAINS
+      query = Query.contains('genres', ['Action', 'Adventure']);
+      expect(query.method, equals(Query.typeContains));
+      expect(query.attribute, equals('genres'));
+      expect(query.values, containsAll(['Action', 'Adventure']));
+
+      // Test creation with TYPE_BETWEEN
+      query = Query.between('releaseYear', 2000, 2020);
+      expect(query.method, equals(Query.typeBetween));
+      expect(query.attribute, equals('releaseYear'));
+      expect(query.values, containsAll([2000, 2020]));
+
+      // Test creation with TYPE_STARTS_WITH
+      query = Query.startsWith('name', 'The');
+      expect(query.method, equals(Query.typeStartsWith));
+      expect(query.attribute, equals('name'));
+      expect(query.values, contains('The'));
+
+      // Test creation with TYPE_ENDS_WITH
+      query = Query.endsWith('name', 'Man');
+      expect(query.method, equals(Query.typeEndsWith));
+      expect(query.attribute, equals('name'));
+      expect(query.values, contains('Man'));
+
+      // Test creation with TYPE_LIMIT using helper
+      query = Query.limit(5);
+      expect(query.method, equals(Query.typeLimit));
+      expect(query.values, contains(5));
+
+      // Test creation with TYPE_OFFSET using helper
+      query = Query.offset(10);
+      expect(query.method, equals(Query.typeOffset));
+      expect(query.values, contains(10));
+
+      // Test Query::select method
+      query = Query.select(['title', 'director']);
+      expect(query.method, equals(Query.typeSelect));
+      expect(query.values, containsAll(['title', 'director']));
+    });
+
+    test('Query Parsing', () {
+      var jsonString = Query.equal('title', ['Iron Man']).toString();
+      var query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"equal","attribute":"title","values":["Iron Man"]}'));
+      expect(query.method, equals('equal'));
+      expect(query.attribute, equals('title'));
+      expect(query.values, contains('Iron Man'));
+
+      // Testing OR logic
+      var json = Query.or([
+        Query.equal('actors', ['Brad Pitt']),
+        Query.equal('actors', ['Johnny Depp'])
+      ]).toString();
+      query = Query.parse(json);
+
+      expect(query.method, equals(Query.typeOr));
+      expect(query.values.length, 2);
+      expect(query.values[0].method, equals(Query.typeEqual));
+      expect(query.values[0].attribute, equals('actors'));
+      expect(json, equals('{"method":"or","values":[{"method":"equal","attribute":"actors","values":["Brad Pitt"]},{"method":"equal","attribute":"actors","values":["Johnny Depp"]}]}'));
+
+      // Parse with TYPE_LESS_THAN
+      jsonString = Query.lessThan('rating', 5).toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"lessThan","attribute":"rating","values":[5]}'));
+      expect(query.method, equals('lessThan'));
+      expect(query.attribute, equals('rating'));
+      expect(query.values, contains(5));
+
+      // Parse with TYPE_GREATER_THAN_EQUAL
+      jsonString = Query.greaterThanEqual('rating', 8).toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"greaterThanEqual","attribute":"rating","values":[8]}'));
+      expect(query.method, equals('greaterThanEqual'));
+      expect(query.attribute, equals('rating'));
+      expect(query.values, contains(8));
+
+      // Parse with TYPE_NOT_EQUAL
+      jsonString = Query.notEqual('director', 'Nolan').toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"notEqual","attribute":"director","values":["Nolan"]}'));
+      expect(query.method, equals('notEqual'));
+      expect(query.attribute, equals('director'));
+      expect(query.values, contains('Nolan'));
+
+      // Parse with TYPE_SEARCH
+      jsonString = Query.search('keywords', 'hero').toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"search","attribute":"keywords","values":["hero"]}'));
+      expect(query.method, equals('search'));
+      expect(query.attribute, equals('keywords'));
+      expect(query.values, contains('hero'));
+
+      // Parse with TYPE_CURSOR_BEFORE
+      var cursor = Document({'\$id': 'someId'});
+      jsonString = Query.cursorBefore(cursor).toString();
+      query = Query.parse(jsonString);
+      expect(query.method, equals('cursorBefore'));
+      expect(query.values.first, equals('someId'));
+
+      // Parse with TYPE_ORDER_ASC
+      jsonString = Query.orderAsc('rating').toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"orderAsc","attribute":"rating","values":[]}'));
+      expect(query.method, equals('orderAsc'));
+      expect(query.attribute, equals('rating'));
+      expect(query.values, isEmpty);
+
+      // Parse with TYPE_IS_NULL
+      jsonString = Query.isNull('availability').toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"isNull","attribute":"availability","values":[]}'));
+      expect(query.method, equals('isNull'));
+      expect(query.attribute, equals('availability'));
+      expect(query.values, isEmpty);
+
+      // Parse with TYPE_IS_NOT_NULL
+      jsonString = Query.isNotNull('availability').toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"isNotNull","attribute":"availability","values":[]}'));
+      expect(query.method, equals('isNotNull'));
+      expect(query.attribute, equals('availability'));
+      expect(query.values, isEmpty);
+
+      // Parse with TYPE_CONTAINS
+      jsonString = Query.contains('tags', ['new', 'sale']).toString();
+      query = Query.parse(jsonString);
+      expect(jsonString, equals('{"method":"contains","attribute":"tags","values":["new","sale"]}'));
+      expect(query.method, equals('contains'));
+      expect(query.attribute, equals('tags'));
+      expect(query.values, containsAll(['new', 'sale']));
+
+      // Parse with TYPE_AND
+      jsonString = Query.and([
+        Query.equal('category', ['book']),
+        Query.greaterThan('price', 20)
+      ]).toString();
+      query = Query.parse(jsonString);
+      expect(query.method, equals('and'));
+      expect(query.values.length, 2);
+      expect(query.values[0].method, equals(Query.typeEqual));
+      expect(query.values[1].method, equals(Query.typeGreater));
+
+      // Parse with TYPE_OR
+      jsonString = Query.or([
+        Query.equal('author', ['J.K. Rowling']),
+        Query.lessThan('year', 2000)
+      ]).toString();
+      query = Query.parse(jsonString);
+      expect(query.method, equals('or'));
+      expect(query.values.length, 2);
+      expect(query.values[0].method, equals(Query.typeEqual));
+      expect(query.values[1].method, equals(Query.typeLesser));
+      
+    });
+
+    test('isMethod Check', () {
+      expect(Query.isMethod(Query.typeEqual), isTrue);
+      expect(Query.isMethod(Query.typeNotEqual), isTrue);
+      expect(Query.isMethod(Query.typeLesser), isTrue);
+      expect(Query.isMethod(Query.typeLesserEqual), isTrue);
+      expect(Query.isMethod(Query.typeGreater), isTrue);
+      expect(Query.isMethod(Query.typeGreaterEqual), isTrue);
+      expect(Query.isMethod(Query.typeContains), isTrue);
+      expect(Query.isMethod(Query.typeSearch), isTrue);
+      expect(Query.isMethod(Query.typeIsNull), isTrue);
+      expect(Query.isMethod(Query.typeIsNotNull), isTrue);
+      expect(Query.isMethod(Query.typeBetween), isTrue);
+      expect(Query.isMethod(Query.typeStartsWith), isTrue);
+      expect(Query.isMethod(Query.typeEndsWith), isTrue);
+      expect(Query.isMethod(Query.typeSelect), isTrue);
+      expect(Query.isMethod(Query.typeOrderDesc), isTrue);
+      expect(Query.isMethod(Query.typeOrderAsc), isTrue);
+      expect(Query.isMethod(Query.typeLimit), isTrue);
+      expect(Query.isMethod(Query.typeOffset), isTrue);
+      expect(Query.isMethod(Query.typeCursorAfter), isTrue);
+      expect(Query.isMethod(Query.typeCursorBefore), isTrue);
+      expect(Query.isMethod(Query.typeAnd), isTrue);
+      expect(Query.isMethod(Query.typeOr), isTrue);
+
+      // Nonexistent method checks
+      expect(Query.isMethod('invalidMethod'), isFalse);
+      expect(Query.isMethod(''), isFalse);
+      expect(Query.isMethod('someRandomString'), isFalse);
+    });
+  });
+}