Skip to content

query test #6

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
lohanidamodar wants to merge 1 commit into
base: main
Choose a base branch
from
Draft

query test #6

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
211 changes: 211 additions & 0 deletions packages/utopia_database/test/query_test.dart
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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);
});
});
}