You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1614 lines
68 KiB
1614 lines
68 KiB
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright 2017 Realm Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
#import "RLMTestCase.h"
|
|
|
|
#pragma mark - Test Objects
|
|
|
|
@interface DogExtraObject : RLMObject
|
|
@property NSString *dogName;
|
|
@property int age;
|
|
@property NSString *breed;
|
|
@end
|
|
|
|
@implementation DogExtraObject
|
|
@end
|
|
|
|
@interface BizzaroDog : RLMObject
|
|
@property int dogName;
|
|
@property NSString *age;
|
|
@end
|
|
|
|
@implementation BizzaroDog
|
|
@end
|
|
|
|
@interface PrimaryKeyWithDefault : RLMObject
|
|
@property NSString *stringCol;
|
|
@property int intCol;
|
|
@end
|
|
@implementation PrimaryKeyWithDefault
|
|
+ (NSString *)primaryKey {
|
|
return @"stringCol";
|
|
}
|
|
+ (NSDictionary *)defaultPropertyValues {
|
|
return @{@"intCol": @10};
|
|
}
|
|
@end
|
|
|
|
@interface AllLinks : RLMObject
|
|
@property StringObject *string;
|
|
@property PrimaryStringObject *primaryString;
|
|
@property RLM_GENERIC_ARRAY(IntObject) *intArray;
|
|
@property RLM_GENERIC_ARRAY(PrimaryIntObject) *primaryIntArray;
|
|
@end
|
|
|
|
@implementation AllLinks
|
|
@end
|
|
|
|
@interface AllLinksWithPrimary : RLMObject
|
|
@property NSString *pk;
|
|
@property StringObject *string;
|
|
@property PrimaryStringObject *primaryString;
|
|
@property RLM_GENERIC_ARRAY(IntObject) *intArray;
|
|
@property RLM_GENERIC_ARRAY(PrimaryIntObject) *primaryIntArray;
|
|
@end
|
|
|
|
@implementation AllLinksWithPrimary
|
|
+ (NSString *)primaryKey {
|
|
return @"pk";
|
|
}
|
|
@end
|
|
|
|
@interface PrimaryKeyAndRequiredString : RLMObject
|
|
@property int pk;
|
|
@property NSString *value;
|
|
@end
|
|
@implementation PrimaryKeyAndRequiredString
|
|
+ (NSString *)primaryKey {
|
|
return @"pk";
|
|
}
|
|
+ (NSArray *)requiredProperties {
|
|
return @[@"value"];
|
|
}
|
|
@end
|
|
|
|
|
|
#pragma mark - Tests
|
|
|
|
@interface ObjectCreationTests : RLMTestCase
|
|
@end
|
|
|
|
@implementation ObjectCreationTests
|
|
|
|
#pragma mark - Init With Value
|
|
|
|
- (void)testInitWithInvalidThings {
|
|
RLMAssertThrowsWithReasonMatching([[DogObject alloc] initWithValue:self.nonLiteralNil],
|
|
@"Must provide a non-nil value");
|
|
RLMAssertThrowsWithReasonMatching([[DogObject alloc] initWithValue:NSNull.null],
|
|
@"Must provide a non-nil value");
|
|
RLMAssertThrowsWithReasonMatching([[DogObject alloc] initWithValue:@"name"],
|
|
@"Invalid value 'name' to initialize object of type 'DogObject'");
|
|
}
|
|
|
|
- (void)testInitWithArray {
|
|
auto co = [[CompanyObject alloc] initWithValue:@[]];
|
|
XCTAssertNil(co.name);
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@[@"empty company"]];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@[@"empty company", NSNull.null]];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@[@"empty company", @[]]];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@[@"one employee",
|
|
@[@[@"name", @2, @YES]]]];
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
XCTAssertEqual(co.employees.count, 1U);
|
|
EmployeeObject *eo = co.employees.firstObject;
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
XCTAssertEqual(eo.age, 2);
|
|
XCTAssertEqual(eo.hired, YES);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@[@"one employee", @[eo]]];
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
XCTAssertEqual(co.employees.count, 1U);
|
|
eo = co.employees.firstObject;
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
XCTAssertEqual(eo.age, 2);
|
|
XCTAssertEqual(eo.hired, YES);
|
|
}
|
|
|
|
- (void)testWithNonArrayEnumerableForRLMArrayProperty {
|
|
auto employees = @[@[@"name", @2, @YES], @[@"name 2", @3, @NO]];
|
|
auto co = [[CompanyObject alloc] initWithValue:@[@"one employee", employees.reverseObjectEnumerator]];
|
|
XCTAssertEqual(2U, co.employees.count);
|
|
XCTAssertEqualObjects(@"name 2", co.employees[0].name);
|
|
XCTAssertEqualObjects(@"name", co.employees[1].name);
|
|
}
|
|
|
|
- (void)testInitWithArrayUsesDefaultValuesForMissingFields {
|
|
auto obj = [[NumberDefaultsObject alloc] initWithValue:@[]];
|
|
XCTAssertEqualObjects(obj.intObj, @1);
|
|
XCTAssertEqualObjects(obj.floatObj, @2.2f);
|
|
XCTAssertEqualObjects(obj.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(obj.boolObj, @NO);
|
|
|
|
obj = [[NumberDefaultsObject alloc] initWithValue:@[@10, @22.2f]];
|
|
XCTAssertEqualObjects(obj.intObj, @10);
|
|
XCTAssertEqualObjects(obj.floatObj, @22.2f);
|
|
XCTAssertEqualObjects(obj.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(obj.boolObj, @NO);
|
|
}
|
|
|
|
- (void)testInitWithInvalidArray {
|
|
RLMAssertThrowsWithReason(([[DogObject alloc] initWithValue:@[@"name", @"age"]]),
|
|
@"Invalid value 'age' of type '__NSCFConstantString' for 'int' property 'DogObject.age'.");
|
|
RLMAssertThrowsWithReason(([[DogObject alloc] initWithValue:@[@"name", NSNull.null]]),
|
|
@"Invalid value '(null)' of type '(null)' for 'int' property 'DogObject.age'.");
|
|
RLMAssertThrowsWithReason(([[DogObject alloc] initWithValue:@[@"name", @5, @"too many values"]]),
|
|
@"Invalid array input: more values (3) than properties (2).");
|
|
}
|
|
|
|
- (void)testInitWithDictionary {
|
|
auto co = [[CompanyObject alloc] initWithValue:@{}];
|
|
XCTAssertNil(co.name);
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@{@"name": NSNull.null}];
|
|
XCTAssertNil(co.name);
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@{@"name": @"empty company"}];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@{@"name": @"empty company",
|
|
@"employees": NSNull.null}];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@{@"name": @"empty company",
|
|
@"employees": @[]}];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@{@"name": @"one employee",
|
|
@"employees": @[@[@"name", @2, @YES]]}];
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
XCTAssertEqual(co.employees.count, 1U);
|
|
EmployeeObject *eo = co.employees.firstObject;
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
XCTAssertEqual(eo.age, 2);
|
|
XCTAssertEqual(eo.hired, YES);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@{@"name": @"one employee",
|
|
@"employees": @[@{@"name": @"name",
|
|
@"age": @2,
|
|
@"hired": @YES}]}];
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
XCTAssertEqual(co.employees.count, 1U);
|
|
eo = co.employees.firstObject;
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
XCTAssertEqual(eo.age, 2);
|
|
XCTAssertEqual(eo.hired, YES);
|
|
|
|
co = [[CompanyObject alloc] initWithValue:@{@"name": @"no employees",
|
|
@"extra fields": @"are okay"}];
|
|
XCTAssertEqualObjects(co.name, @"no employees");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
}
|
|
|
|
- (void)testInitWithInvalidDictionary {
|
|
RLMAssertThrowsWithReason(([[DogObject alloc] initWithValue:@{@"name": @"a", @"age": NSNull.null}]),
|
|
@"Invalid value '(null)' of type '(null)' for 'int' property 'DogObject.age'");
|
|
RLMAssertThrowsWithReasonMatching(([[DogObject alloc] initWithValue:@{@"name": @"a", @"age": NSDate.date}]),
|
|
@"Invalid value '20.*' of type '.*Date' for 'int' property 'DogObject.age'");
|
|
}
|
|
|
|
- (void)testInitWithDictionaryUsesDefaultValuesForMissingFields {
|
|
auto obj = [[NumberDefaultsObject alloc] initWithValue:@{}];
|
|
XCTAssertEqualObjects(obj.intObj, @1);
|
|
XCTAssertEqualObjects(obj.floatObj, @2.2f);
|
|
XCTAssertEqualObjects(obj.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(obj.boolObj, @NO);
|
|
|
|
obj = [[NumberDefaultsObject alloc] initWithValue:@{@"intObj": @10}];
|
|
XCTAssertEqualObjects(obj.intObj, @10);
|
|
XCTAssertEqualObjects(obj.floatObj, @2.2f);
|
|
XCTAssertEqualObjects(obj.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(obj.boolObj, @NO);
|
|
}
|
|
|
|
- (void)testInitWithObject {
|
|
auto eo = [[EmployeeObject alloc] init];
|
|
eo.name = @"employee name";
|
|
eo.age = 1;
|
|
eo.hired = NO;
|
|
|
|
auto co = [[CompanyObject alloc] init];
|
|
co.name = @"name";
|
|
[co.employees addObject:eo];
|
|
|
|
auto co2 = [[CompanyObject alloc] initWithValue:co];
|
|
XCTAssertEqualObjects(co.name, co2.name);
|
|
XCTAssertEqual(co.employees[0], co2.employees[0]); // not EqualObjects as it's a shallow copy
|
|
|
|
auto dogExt = [[DogExtraObject alloc] initWithValue:@[@"Fido", @12, @"Poodle"]];
|
|
auto dog = [[DogObject alloc] initWithValue:dogExt];
|
|
XCTAssertEqualObjects(dog.dogName, @"Fido");
|
|
XCTAssertEqual(dog.age, 12);
|
|
|
|
auto owner = [[OwnerObject alloc] initWithValue:@[@"Alex", dogExt]];
|
|
XCTAssertEqualObjects(owner.dog.dogName, @"Fido");
|
|
|
|
auto array1 = [[AllPrimitiveArrays alloc] init];
|
|
[array1.intObj addObject:@2];
|
|
auto array2 = [[AllPrimitiveArrays alloc] initWithValue:array1];
|
|
XCTAssertEqual(array2.intObj.count, 1U);
|
|
XCTAssertEqualObjects(array2.intObj.firstObject, @2);
|
|
}
|
|
|
|
- (void)testInitWithInvalidObject {
|
|
// No overlap in properties
|
|
auto so = [[StringObject alloc] initWithValue:@[@"str"]];
|
|
RLMAssertThrowsWithReason([[IntObject alloc] initWithValue:so], @"missing key 'intCol'");
|
|
|
|
// Dog has some but not all of DogExtra's properties
|
|
auto dog = [[DogObject alloc] initWithValue:@[@"Fido", @10]];
|
|
RLMAssertThrowsWithReason([[DogExtraObject alloc] initWithValue:dog], @"missing key 'breed'");
|
|
|
|
// Same property names, but different types
|
|
RLMAssertThrowsWithReason([[BizzaroDog alloc] initWithValue:dog],
|
|
@"Invalid value 'Fido' of type '__NSCFConstantString' for 'int' property 'BizzaroDog.dogName'");
|
|
}
|
|
|
|
- (void)testInitPrimitiveArraysWithInvalidValues {
|
|
RLMAssertThrowsWithReason([[AllPrimitiveArrays alloc] initWithValue:@{@"intObj": @[NSNull.null]}],
|
|
@"Invalid value '<null>' of type 'NSNull' for 'int' array property 'AllPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([[AllPrimitiveArrays alloc] initWithValue:@{@"intObj": @[@1.1]}],
|
|
@"Invalid value '1.1' of type '__NSCFNumber' for 'int' array property 'AllPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([[AllPrimitiveArrays alloc] initWithValue:@{@"intObj": @[@"0"]}],
|
|
@"Invalid value '0' of type '__NSCFConstantString' for 'int' array property 'AllPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([[AllPrimitiveArrays alloc] initWithValue:@{@"intObj": @1}],
|
|
@"Invalid value (1) for 'int' array property 'AllPrimitiveArrays.intObj': value is not enumerable.");
|
|
}
|
|
|
|
- (void)testInitWithCustomAccessors {
|
|
// Create with array
|
|
auto ca = [[CustomAccessorsObject alloc] initWithValue:@[@"a", @1]];
|
|
XCTAssertEqualObjects(ca.name, @"a");
|
|
XCTAssertEqual(ca.age, 1);
|
|
|
|
// Create with dictionary
|
|
ca = [[CustomAccessorsObject alloc] initWithValue:@{@"name": @"b", @"age": @2}];
|
|
XCTAssertEqualObjects(ca.name, @"b");
|
|
XCTAssertEqual(ca.age, 2);
|
|
|
|
// Create with KVC-compatible object
|
|
ca = [[CustomAccessorsObject alloc] initWithValue:ca];
|
|
XCTAssertEqualObjects(ca.name, @"b");
|
|
XCTAssertEqual(ca.age, 2);
|
|
}
|
|
|
|
- (void)testInitWithRenamedColumns {
|
|
// Create with array
|
|
auto obj = [[RenamedProperties1 alloc] initWithValue:@[@1, @"a"]];
|
|
XCTAssertEqual(obj.propA, 1);
|
|
XCTAssertEqualObjects(obj.propB, @"a");
|
|
|
|
// Create with dictionary
|
|
obj = [[RenamedProperties1 alloc] initWithValue:@{@"propB": @"b", @"propA": @2}];
|
|
XCTAssertEqual(obj.propA, 2);
|
|
XCTAssertEqualObjects(obj.propB, @"b");
|
|
|
|
// Create with KVC-compatible object
|
|
obj = [[RenamedProperties1 alloc] initWithValue:obj];
|
|
XCTAssertEqual(obj.propA, 2);
|
|
XCTAssertEqualObjects(obj.propB, @"b");
|
|
}
|
|
|
|
- (void)testInitAllPropertyTypes {
|
|
auto now = [NSDate date];
|
|
auto bytes = [NSData dataWithBytes:"a" length:1];
|
|
auto so = [[StringObject alloc] init];
|
|
so.stringCol = @"string";
|
|
auto ao = [[AllTypesObject alloc] initWithValue:@[@YES, @1, @1.1f, @1.11,
|
|
@"string", bytes,
|
|
now, @YES, @11, so]];
|
|
XCTAssertEqual(ao.boolCol, YES);
|
|
XCTAssertEqual(ao.intCol, 1);
|
|
XCTAssertEqual(ao.floatCol, 1.1f);
|
|
XCTAssertEqual(ao.doubleCol, 1.11);
|
|
XCTAssertEqualObjects(ao.stringCol, @"string");
|
|
XCTAssertEqualObjects(ao.binaryCol, bytes);
|
|
XCTAssertEqual(ao.dateCol, now);
|
|
XCTAssertEqual(ao.cBoolCol, true);
|
|
XCTAssertEqual(ao.longCol, 11);
|
|
XCTAssertEqual(ao.objectCol, so);
|
|
|
|
auto opt = [[AllOptionalTypes alloc] initWithValue:@[NSNull.null, NSNull.null,
|
|
NSNull.null, NSNull.null,
|
|
NSNull.null, NSNull.null,
|
|
NSNull.null]];
|
|
XCTAssertNil(opt.intObj);
|
|
XCTAssertNil(opt.boolObj);
|
|
XCTAssertNil(opt.floatObj);
|
|
XCTAssertNil(opt.doubleObj);
|
|
XCTAssertNil(opt.date);
|
|
XCTAssertNil(opt.data);
|
|
XCTAssertNil(opt.string);
|
|
|
|
opt = [[AllOptionalTypes alloc] initWithValue:@[@1, @2.2f, @3.3, @YES,
|
|
@"str", bytes, now]];
|
|
XCTAssertEqualObjects(opt.intObj, @1);
|
|
XCTAssertEqualObjects(opt.boolObj, @YES);
|
|
XCTAssertEqualObjects(opt.floatObj, @2.2f);
|
|
XCTAssertEqualObjects(opt.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(opt.date, now);
|
|
XCTAssertEqualObjects(opt.data, bytes);
|
|
XCTAssertEqualObjects(opt.string, @"str");
|
|
|
|
auto arrays = [[AllPrimitiveArrays alloc] initWithValue:@{@"intObj": @[@1, @2, @3],
|
|
@"boolObj": @[@YES, @NO],
|
|
@"floatObj": @[@1.1f, @2.2f],
|
|
@"doubleObj": @[@3.3, @4.4],
|
|
@"stringObj": @[@"a", @"b"],
|
|
@"dateObj": @[now],
|
|
@"dataObj": @[bytes]}];
|
|
XCTAssertEqual(3U, arrays.intObj.count);
|
|
XCTAssertEqual(2U, arrays.boolObj.count);
|
|
XCTAssertEqual(2U, arrays.floatObj.count);
|
|
XCTAssertEqual(2U, arrays.doubleObj.count);
|
|
XCTAssertEqual(2U, arrays.stringObj.count);
|
|
XCTAssertEqual(1U, arrays.dateObj.count);
|
|
XCTAssertEqual(1U, arrays.dataObj.count);
|
|
|
|
XCTAssertEqualObjects([arrays.intObj valueForKey:@"self"], (@[@1, @2, @3]));
|
|
XCTAssertEqualObjects([arrays.boolObj valueForKey:@"self"], (@[@YES, @NO]));
|
|
XCTAssertEqualObjects([arrays.floatObj valueForKey:@"self"], (@[@1.1f, @2.2f]));
|
|
XCTAssertEqualObjects([arrays.doubleObj valueForKey:@"self"], (@[@3.3, @4.4]));
|
|
XCTAssertEqualObjects([arrays.stringObj valueForKey:@"self"], (@[@"a", @"b"]));
|
|
XCTAssertEqualObjects([arrays.dateObj valueForKey:@"self"], (@[now]));
|
|
XCTAssertEqualObjects([arrays.dataObj valueForKey:@"self"], (@[bytes]));
|
|
}
|
|
|
|
- (void)testInitValidatesNumberTypes {
|
|
XCTAssertNoThrow(([[NumberObject alloc] initWithValue:@{}]));
|
|
RLMAssertThrowsWithReason(([[NumberObject alloc] initWithValue:@{@"intObj": @1.1}]),
|
|
@"Invalid value '1.1' of type '__NSCFNumber' for 'int?' property 'NumberObject.intObj'.");
|
|
RLMAssertThrowsWithReason(([[NumberObject alloc] initWithValue:@{@"intObj": @1.1f}]),
|
|
@"Invalid value '1.1' of type '__NSCFNumber' for 'int?' property 'NumberObject.intObj'.");
|
|
|
|
XCTAssertNoThrow(([[NumberObject alloc] initWithValue:@{@"boolObj": @YES}]));
|
|
XCTAssertNoThrow(([[NumberObject alloc] initWithValue:@{@"boolObj": @1}]));
|
|
XCTAssertNoThrow(([[NumberObject alloc] initWithValue:@{@"boolObj": @0}]));
|
|
// This error is kinda bad....
|
|
RLMAssertThrowsWithReason(([[NumberObject alloc] initWithValue:@{@"boolObj": @1.0}]),
|
|
@"Invalid value '1' of type '__NSCFNumber' for 'bool?' property 'NumberObject.boolObj'.");
|
|
RLMAssertThrowsWithReason(([[NumberObject alloc] initWithValue:@{@"boolObj": @1.0f}]),
|
|
@"Invalid value '1' of type '__NSCFNumber' for 'bool?' property 'NumberObject.boolObj'.");
|
|
RLMAssertThrowsWithReason(([[NumberObject alloc] initWithValue:@{@"boolObj": @2}]),
|
|
@"Invalid value '2' of type '__NSCFNumber' for 'bool?' property 'NumberObject.boolObj'.");
|
|
|
|
XCTAssertNoThrow(([[NumberObject alloc] initWithValue:@{@"floatObj": @1.1}]));
|
|
RLMAssertThrowsWithReasonMatching(([[NumberObject alloc] initWithValue:@{@"floatObj": @DBL_MAX}]),
|
|
@"Invalid value '.*' of type '__NSCFNumber' for 'float\\?' property 'NumberObject.floatObj'");
|
|
|
|
XCTAssertNoThrow(([[NumberObject alloc] initWithValue:@{@"doubleObj": @DBL_MAX}]));
|
|
}
|
|
|
|
#pragma mark - Create
|
|
|
|
- (void)testCreateWithArray {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto co = [CompanyObject createInRealm:realm withValue:@[@"empty company", NSNull.null]];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@[@"empty company", @[]]];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@[@"one employee",
|
|
@[@[@"name", @2, @YES]]]];
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
XCTAssertEqual(co.employees.count, 1U);
|
|
EmployeeObject *eo = co.employees.firstObject;
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
XCTAssertEqual(eo.age, 2);
|
|
XCTAssertEqual(eo.hired, YES);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithInvalidArray {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason(([DogObject createInRealm:realm withValue:@[@"name", @"age"]]),
|
|
@"Invalid value 'age' of type '__NSCFConstantString' for 'int' property 'DogObject.age'");
|
|
RLMAssertThrowsWithReason(([DogObject createInRealm:realm withValue:@[@"name", NSNull.null]]),
|
|
@"Invalid value '<null>' of type 'NSNull' for 'int' property 'DogObject.age'");
|
|
RLMAssertThrowsWithReason(([DogObject createInRealm:realm withValue:@[@"name", @5, @"too many values"]]),
|
|
@"Invalid array input: more values (3) than properties (2).");
|
|
RLMAssertThrowsWithReason(([PrimaryStringObject createInRealm:realm withValue:@[]]),
|
|
@"Missing value for property 'PrimaryStringObject.stringCol'");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithDictionary {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto co = [CompanyObject createInRealm:realm withValue:@{}];
|
|
XCTAssertNil(co.name);
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@{@"name": NSNull.null}];
|
|
XCTAssertNil(co.name);
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@{@"name": @"empty company"}];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@{@"name": @"empty company",
|
|
@"employees": NSNull.null}];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@{@"name": @"empty company",
|
|
@"employees": @[]}];
|
|
XCTAssertEqualObjects(co.name, @"empty company");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@{@"name": @"one employee",
|
|
@"employees": @[@[@"name", @2, @YES]]}];
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
XCTAssertEqual(co.employees.count, 1U);
|
|
EmployeeObject *eo = co.employees.firstObject;
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
XCTAssertEqual(eo.age, 2);
|
|
XCTAssertEqual(eo.hired, YES);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@{@"name": @"one employee",
|
|
@"employees": @[@{@"name": @"name",
|
|
@"age": @2,
|
|
@"hired": @YES}]}];
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
XCTAssertEqual(co.employees.count, 1U);
|
|
eo = co.employees.firstObject;
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
XCTAssertEqual(eo.age, 2);
|
|
XCTAssertEqual(eo.hired, YES);
|
|
|
|
co = [CompanyObject createInRealm:realm withValue:@{@"name": @"no employees",
|
|
@"extra fields": @"are okay"}];
|
|
XCTAssertEqualObjects(co.name, @"no employees");
|
|
XCTAssertEqual(co.employees.count, 0U);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithInvalidDictionary {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason(([DogObject createInRealm:realm withValue:@{@"name": @"a", @"age": NSNull.null}]),
|
|
@"Invalid value '<null>' of type 'NSNull' for 'int' property 'DogObject.age'");
|
|
RLMAssertThrowsWithReasonMatching(([DogObject createInRealm:realm withValue:@{@"name": @"a", @"age": NSDate.date}]),
|
|
@"Invalid value '20.*' for 'int' property 'DogObject.age'");
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithObject {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto eo = [[EmployeeObject alloc] init];
|
|
eo.name = @"employee name";
|
|
eo.age = 1;
|
|
eo.hired = NO;
|
|
|
|
auto co = [[CompanyObject alloc] init];
|
|
co.name = @"name";
|
|
[co.employees addObject:eo];
|
|
|
|
auto co2 = [CompanyObject createInRealm:realm withValue:co];
|
|
XCTAssertEqualObjects(co.name, co2.name);
|
|
// Deep copy, so it's a different object
|
|
XCTAssertFalse([co.employees[0] isEqualToObject:co2.employees[0]]);
|
|
XCTAssertEqualObjects(co.employees[0].name, co2.employees[0].name);
|
|
|
|
auto dogExt = [DogExtraObject createInRealm:realm withValue:@[@"Fido", @12, @"Poodle"]];
|
|
auto dog = [DogObject createInRealm:realm withValue:dogExt];
|
|
XCTAssertEqualObjects(dog.dogName, @"Fido");
|
|
XCTAssertEqual(dog.age, 12);
|
|
|
|
auto owner = [OwnerObject createInRealm:realm withValue:@[@"Alex", dogExt]];
|
|
XCTAssertEqualObjects(owner.dog.dogName, @"Fido");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithInvalidObject {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReasonMatching([DogObject createInRealm:realm withValue:self.nonLiteralNil],
|
|
@"Must provide a non-nil value");
|
|
RLMAssertThrowsWithReasonMatching([DogObject createInRealm:realm withValue:NSNull.null],
|
|
@"Must provide a non-nil value");
|
|
RLMAssertThrowsWithReasonMatching([DogObject createInRealm:realm withValue:@""],
|
|
@"Invalid value '' to initialize object of type 'DogObject'");
|
|
|
|
// No overlap in properties
|
|
auto so = [StringObject createInRealm:realm withValue:@[@"str"]];
|
|
RLMAssertThrowsWithReasonMatching([IntObject createInRealm:realm withValue:so], @"missing key 'intCol'");
|
|
|
|
// Dog has some but not all of DogExtra's properties
|
|
auto dog = [DogObject createInRealm:realm withValue:@[@"Fido", @10]];
|
|
RLMAssertThrowsWithReasonMatching([DogExtraObject createInRealm:realm withValue:dog],
|
|
@"missing key 'breed'");
|
|
|
|
// Same property names, but different types
|
|
RLMAssertThrowsWithReasonMatching([BizzaroDog createInRealm:realm withValue:dog],
|
|
@"Invalid value 'Fido' of type '.*' for 'int' property 'BizzaroDog.dogName'");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateAllPropertyTypes {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto now = [NSDate date];
|
|
auto bytes = [NSData dataWithBytes:"a" length:1];
|
|
auto so = [[StringObject alloc] init];
|
|
so.stringCol = @"string";
|
|
auto ao = [AllTypesObject createInRealm:realm withValue:@[@YES, @1, @1.1f, @1.11,
|
|
@"string", bytes,
|
|
now, @YES, @11, so]];
|
|
XCTAssertEqual(ao.boolCol, YES);
|
|
XCTAssertEqual(ao.intCol, 1);
|
|
XCTAssertEqual(ao.floatCol, 1.1f);
|
|
XCTAssertEqual(ao.doubleCol, 1.11);
|
|
XCTAssertEqualObjects(ao.stringCol, @"string");
|
|
XCTAssertEqualObjects(ao.binaryCol, bytes);
|
|
XCTAssertEqualObjects(ao.dateCol, now);
|
|
XCTAssertEqual(ao.cBoolCol, true);
|
|
XCTAssertEqual(ao.longCol, 11);
|
|
XCTAssertNotEqual(ao.objectCol, so);
|
|
XCTAssertEqualObjects(ao.objectCol.stringCol, @"string");
|
|
|
|
auto opt = [AllOptionalTypes createInRealm:realm withValue:@[NSNull.null, NSNull.null,
|
|
NSNull.null, NSNull.null,
|
|
NSNull.null, NSNull.null,
|
|
NSNull.null]];
|
|
XCTAssertNil(opt.intObj);
|
|
XCTAssertNil(opt.boolObj);
|
|
XCTAssertNil(opt.floatObj);
|
|
XCTAssertNil(opt.doubleObj);
|
|
XCTAssertNil(opt.date);
|
|
XCTAssertNil(opt.data);
|
|
XCTAssertNil(opt.string);
|
|
|
|
opt = [AllOptionalTypes createInRealm:realm withValue:@[@1, @2.2f, @3.3, @YES,
|
|
@"str", bytes, now]];
|
|
XCTAssertEqualObjects(opt.intObj, @1);
|
|
XCTAssertEqualObjects(opt.boolObj, @YES);
|
|
XCTAssertEqualObjects(opt.floatObj, @2.2f);
|
|
XCTAssertEqualObjects(opt.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(opt.date, now);
|
|
XCTAssertEqualObjects(opt.data, bytes);
|
|
XCTAssertEqualObjects(opt.string, @"str");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateRequiredPrimitiveArrays {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto now = [NSDate date];
|
|
auto bytes = [NSData dataWithBytes:"a" length:1];
|
|
auto req = [AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@1, @2, @3],
|
|
@"boolObj": @[@YES, @NO],
|
|
@"floatObj": @[@1.1f, @2.2f],
|
|
@"doubleObj": @[@3.3, @4.4],
|
|
@"stringObj": @[@"a", @"b"],
|
|
@"dateObj": @[now],
|
|
@"dataObj": @[bytes]}];
|
|
XCTAssertEqual(3U, req.intObj.count);
|
|
XCTAssertEqual(2U, req.boolObj.count);
|
|
XCTAssertEqual(2U, req.floatObj.count);
|
|
XCTAssertEqual(2U, req.doubleObj.count);
|
|
XCTAssertEqual(2U, req.stringObj.count);
|
|
XCTAssertEqual(1U, req.dateObj.count);
|
|
XCTAssertEqual(1U, req.dataObj.count);
|
|
|
|
XCTAssertEqualObjects([req.intObj valueForKey:@"self"], (@[@1, @2, @3]));
|
|
XCTAssertEqualObjects([req.boolObj valueForKey:@"self"], (@[@YES, @NO]));
|
|
XCTAssertEqualObjects([req.floatObj valueForKey:@"self"], (@[@1.1f, @2.2f]));
|
|
XCTAssertEqualObjects([req.doubleObj valueForKey:@"self"], (@[@3.3, @4.4]));
|
|
XCTAssertEqualObjects([req.stringObj valueForKey:@"self"], (@[@"a", @"b"]));
|
|
XCTAssertEqualObjects([req.dateObj valueForKey:@"self"], (@[now]));
|
|
XCTAssertEqualObjects([req.dataObj valueForKey:@"self"], (@[bytes]));
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
#if 0
|
|
- (void)testCreateRequiredPrimitiveArraysWithNonNSArrayEnumerable {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto now = [NSDate date];
|
|
auto bytes = [NSData dataWithBytes:"a" length:1];
|
|
auto req = [AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@1, @2, @3].reverseObjectEnumerator,
|
|
@"boolObj": @[@YES, @NO].reverseObjectEnumerator,
|
|
@"floatObj": @[@1.1f, @2.2f].reverseObjectEnumerator,
|
|
@"doubleObj": @[@3.3, @4.4].reverseObjectEnumerator,
|
|
@"stringObj": @[@"a", @"b"].reverseObjectEnumerator,
|
|
@"dateObj": @[now].reverseObjectEnumerator,
|
|
@"dataObj": @[bytes].reverseObjectEnumerator}];
|
|
XCTAssertEqual(3U, req.intObj.count);
|
|
XCTAssertEqual(2U, req.boolObj.count);
|
|
XCTAssertEqual(2U, req.floatObj.count);
|
|
XCTAssertEqual(2U, req.doubleObj.count);
|
|
XCTAssertEqual(2U, req.stringObj.count);
|
|
XCTAssertEqual(1U, req.dateObj.count);
|
|
XCTAssertEqual(1U, req.dataObj.count);
|
|
|
|
XCTAssertEqualObjects([req.intObj valueForKey:@"self"], (@[@3, @2, @1]));
|
|
XCTAssertEqualObjects([req.boolObj valueForKey:@"self"], (@[@NO, @YES]));
|
|
XCTAssertEqualObjects([req.floatObj valueForKey:@"self"], (@[@2.2f, @1.1f]));
|
|
XCTAssertEqualObjects([req.doubleObj valueForKey:@"self"], (@[@4.4, @3.3]));
|
|
XCTAssertEqualObjects([req.stringObj valueForKey:@"self"], (@[@"b", @"a"]));
|
|
XCTAssertEqualObjects([req.dateObj valueForKey:@"self"], (@[now]));
|
|
XCTAssertEqualObjects([req.dataObj valueForKey:@"self"], (@[bytes]));
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
#endif
|
|
|
|
- (void)testCreatePrimitiveArraysWithNSNull {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto req = [AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": NSNull.null,
|
|
@"boolObj": NSNull.null,
|
|
@"floatObj": NSNull.null,
|
|
@"doubleObj": NSNull.null,
|
|
@"stringObj": NSNull.null,
|
|
@"dateObj": NSNull.null,
|
|
@"dataObj": NSNull.null}];
|
|
XCTAssertEqual(0U, req.intObj.count);
|
|
XCTAssertEqual(0U, req.boolObj.count);
|
|
XCTAssertEqual(0U, req.floatObj.count);
|
|
XCTAssertEqual(0U, req.doubleObj.count);
|
|
XCTAssertEqual(0U, req.stringObj.count);
|
|
XCTAssertEqual(0U, req.dateObj.count);
|
|
XCTAssertEqual(0U, req.dataObj.count);
|
|
}
|
|
|
|
- (void)testCreatePrimitiveArraysWithMissingKeys {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto req = [AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@1, @2, @2],
|
|
@"dataObj": NSNull.null}];
|
|
XCTAssertEqual(3U, req.intObj.count);
|
|
XCTAssertEqual(0U, req.boolObj.count);
|
|
XCTAssertEqual(0U, req.floatObj.count);
|
|
XCTAssertEqual(0U, req.doubleObj.count);
|
|
XCTAssertEqual(0U, req.stringObj.count);
|
|
XCTAssertEqual(0U, req.dateObj.count);
|
|
XCTAssertEqual(0U, req.dataObj.count);
|
|
}
|
|
|
|
- (void)testCreateRequiredPrimitiveArraysWithInvalidValues {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason([AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[NSNull.null]}],
|
|
@"Invalid value '<null>' of type 'NSNull' for 'int' array property 'AllPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@1.1]}],
|
|
@"Invalid value '1.1' of type '__NSCFNumber' for 'int' array property 'AllPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@"0"]}],
|
|
@"Invalid value '0' of type '__NSCFConstantString' for 'int' array property 'AllPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([AllPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @1}],
|
|
@"Invalid value (1) for 'int' array property 'AllPrimitiveArrays.intObj': value is not enumerable.");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOptionalPrimitiveArrays {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
auto now = [NSDate date];
|
|
auto bytes = [NSData dataWithBytes:"a" length:1];
|
|
auto req = [AllOptionalPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@1, @2, @3, NSNull.null],
|
|
@"boolObj": @[@YES, @NO, NSNull.null],
|
|
@"floatObj": @[@1.1f, @2.2f, NSNull.null],
|
|
@"doubleObj": @[@3.3, @4.4, NSNull.null],
|
|
@"stringObj": @[@"a", @"b", NSNull.null],
|
|
@"dateObj": @[now, NSNull.null],
|
|
@"dataObj": @[bytes, NSNull.null]}];
|
|
XCTAssertEqual(4U, req.intObj.count);
|
|
XCTAssertEqual(3U, req.boolObj.count);
|
|
XCTAssertEqual(3U, req.floatObj.count);
|
|
XCTAssertEqual(3U, req.doubleObj.count);
|
|
XCTAssertEqual(3U, req.stringObj.count);
|
|
XCTAssertEqual(2U, req.dateObj.count);
|
|
XCTAssertEqual(2U, req.dataObj.count);
|
|
|
|
XCTAssertEqualObjects([req.intObj valueForKey:@"self"], (@[@1, @2, @3, NSNull.null]));
|
|
XCTAssertEqualObjects([req.boolObj valueForKey:@"self"], (@[@YES, @NO, NSNull.null]));
|
|
XCTAssertEqualObjects([req.floatObj valueForKey:@"self"], (@[@1.1f, @2.2f, NSNull.null]));
|
|
XCTAssertEqualObjects([req.doubleObj valueForKey:@"self"], (@[@3.3, @4.4, NSNull.null]));
|
|
XCTAssertEqualObjects([req.stringObj valueForKey:@"self"], (@[@"a", @"b", NSNull.null]));
|
|
XCTAssertEqualObjects([req.dateObj valueForKey:@"self"], (@[now, NSNull.null]));
|
|
XCTAssertEqualObjects([req.dataObj valueForKey:@"self"], (@[bytes, NSNull.null]));
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOptionalPrimitiveArraysWithInvalidValues {
|
|
auto realm = RLMRealm.defaultRealm;
|
|
[realm beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason([AllOptionalPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@1.1]}],
|
|
@"Invalid value '1.1' of type '__NSCFNumber' for 'int?' array property 'AllOptionalPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([AllOptionalPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @[@"0"]}],
|
|
@"Invalid value '0' of type '__NSCFConstantString' for 'int?' array property 'AllOptionalPrimitiveArrays.intObj'.");
|
|
RLMAssertThrowsWithReason([AllOptionalPrimitiveArrays createInRealm:realm
|
|
withValue:@{@"intObj": @1}],
|
|
@"Invalid value (1) for 'int?' array property 'AllOptionalPrimitiveArrays.intObj': value is not enumerable.");
|
|
}
|
|
|
|
- (void)testCreateUsesDefaultValuesForMissingDictionaryKeys {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj = [NumberDefaultsObject createInRealm:realm withValue:@{}];
|
|
XCTAssertEqualObjects(obj.intObj, @1);
|
|
XCTAssertEqualObjects(obj.floatObj, @2.2f);
|
|
XCTAssertEqualObjects(obj.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(obj.boolObj, @NO);
|
|
|
|
obj = [NumberDefaultsObject createInRealm:realm withValue:@{@"intObj": @10}];
|
|
XCTAssertEqualObjects(obj.intObj, @10);
|
|
XCTAssertEqualObjects(obj.floatObj, @2.2f);
|
|
XCTAssertEqualObjects(obj.doubleObj, @3.3);
|
|
XCTAssertEqualObjects(obj.boolObj, @NO);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOnManagedObjectInSameRealmShallowCopies {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto so = [StringObject createInRealm:realm withValue:@[@"str"]];
|
|
auto pso = [PrimaryStringObject createInRealm:realm withValue:@[@"pk", @1]];
|
|
auto io = [IntObject createInRealm:realm withValue:@[@2]];
|
|
auto pio = [PrimaryIntObject createInRealm:realm withValue:@[@3]];
|
|
|
|
auto links = [AllLinks createInRealm:realm withValue:@[so, pso, @[io, io], @[pio, pio]]];
|
|
auto copy = [AllLinks createInRealm:realm withValue:links];
|
|
|
|
XCTAssertEqual(2U, [AllLinks allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(1U, [StringObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(1U, [IntObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(1U, [PrimaryIntObject allObjectsInRealm:realm].count);
|
|
|
|
XCTAssertTrue([links.string isEqualToObject:so]);
|
|
XCTAssertTrue([copy.string isEqualToObject:so]);
|
|
XCTAssertTrue([links.primaryString isEqualToObject:pso]);
|
|
XCTAssertTrue([copy.primaryString isEqualToObject:pso]);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOnManagedObjectInDifferentRealmDeepCopies {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
auto realm2 = [self realmWithTestPath];
|
|
[realm2 beginWriteTransaction];
|
|
|
|
auto so = [StringObject createInRealm:realm withValue:@[@"str"]];
|
|
auto pso = [PrimaryStringObject createInRealm:realm withValue:@[@"pk", @1]];
|
|
auto io = [IntObject createInRealm:realm withValue:@[@2]];
|
|
auto pio = [PrimaryIntObject createInRealm:realm withValue:@[@3]];
|
|
|
|
auto links = [AllLinks createInRealm:realm withValue:@[so, pso, @[io, io], @[pio]]];
|
|
[AllLinks createInRealm:realm2 withValue:links];
|
|
|
|
XCTAssertEqual(1U, [AllLinks allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(1U, [StringObject allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(2U, [IntObject allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(1U, [PrimaryIntObject allObjectsInRealm:realm2].count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
[realm2 cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOnManagedObjectInDifferentRealmDoesntReallyWorkUsefullyWithLinkedPKs {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
auto realm2 = [self realmWithTestPath];
|
|
[realm2 beginWriteTransaction];
|
|
|
|
auto pio = [PrimaryIntObject createInRealm:realm withValue:@[@3]];
|
|
auto links = [AllLinks createInRealm:realm withValue:@[NSNull.null, NSNull.null, NSNull.null, @[pio, pio]]];
|
|
RLMAssertThrowsWithReason([AllLinks createInRealm:realm2 withValue:links],
|
|
@"existing primary key value '3'");
|
|
|
|
[realm cancelWriteTransaction];
|
|
[realm2 cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithInvalidatedObject {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
|
|
[realm beginWriteTransaction];
|
|
auto obj1 = [IntObject createInRealm:realm withValue:@[@0]];
|
|
auto obj2 = [IntObject createInRealm:realm withValue:@[@1]];
|
|
id obj1alias = [IntObject allObjectsInRealm:realm].firstObject;
|
|
|
|
[realm deleteObject:obj1];
|
|
RLMAssertThrowsWithReasonMatching([IntObject createInRealm:realm withValue:obj1],
|
|
@"Object has been deleted or invalidated.");
|
|
RLMAssertThrowsWithReasonMatching([IntObject createInRealm:realm withValue:obj1alias],
|
|
@"Object has been deleted or invalidated.");
|
|
|
|
[realm commitWriteTransaction];
|
|
[realm invalidate];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrowsWithReasonMatching([IntObject createInRealm:realm withValue:obj2],
|
|
@"Object has been deleted or invalidated.");
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOutsideWriteTransaction {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
RLMAssertThrowsWithReasonMatching([IntObject createInRealm:realm withValue:@[@0]],
|
|
@"call beginWriteTransaction");
|
|
}
|
|
|
|
- (void)testCreateInNilRealm {
|
|
RLMAssertThrowsWithReasonMatching(([IntObject createInRealm:self.nonLiteralNil withValue:@[@0]]),
|
|
@"Realm must not be nil");
|
|
}
|
|
|
|
- (void)testCreatingObjectWithoutAnyPropertiesThrows {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrows([AbstractObject createInRealm:realm withValue:@[]]);
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithNonEnumerableValueForArrayProperty {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrowsWithReason(([CompanyObject createInRealm:realm withValue:@[@"one employee", @1]]),
|
|
@"Invalid value (1) for 'EmployeeObject' array property 'CompanyObject.employees': value is not enumerable.");
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithNonArrayEnumerableValueForArrayProperty {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto employees = @[@[@"name", @2, @YES], @[@"name 2", @3, @NO]];
|
|
auto co = [CompanyObject createInRealm:realm withValue:@[@"one employee", employees.reverseObjectEnumerator]];
|
|
XCTAssertEqual(2U, co.employees.count);
|
|
XCTAssertEqualObjects(@"name 2", co.employees[0].name);
|
|
XCTAssertEqualObjects(@"name", co.employees[1].name);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithCustomAccessors {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
// Create with array
|
|
auto ca = [CustomAccessorsObject createInRealm:realm withValue:@[@"a", @1]];
|
|
XCTAssertEqualObjects(ca.name, @"a");
|
|
XCTAssertEqual(ca.age, 1);
|
|
|
|
// Create with dictionary
|
|
ca = [CustomAccessorsObject createInRealm:realm withValue:@{@"name": @"b", @"age": @2}];
|
|
XCTAssertEqualObjects(ca.name, @"b");
|
|
XCTAssertEqual(ca.age, 2);
|
|
|
|
// Create with KVC-compatible object
|
|
auto ca2 = [CustomAccessorsObject createInRealm:realm withValue:ca];
|
|
XCTAssertEqualObjects(ca2.name, @"b");
|
|
XCTAssertEqual(ca2.age, 2);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateWithRenamedColumns {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
// Create with array
|
|
auto obj = [RenamedProperties1 createInRealm:realm withValue:@[@1, @"a"]];
|
|
XCTAssertEqual(obj.propA, 1);
|
|
XCTAssertEqualObjects(obj.propB, @"a");
|
|
|
|
// Create with dictionary
|
|
obj = [RenamedProperties1 createInRealm:realm withValue:@{@"propB": @"b", @"propA": @2}];
|
|
XCTAssertEqual(obj.propA, 2);
|
|
XCTAssertEqualObjects(obj.propB, @"b");
|
|
|
|
// Create with KVC-compatible object
|
|
obj = [RenamedProperties1 createInRealm:realm withValue:obj];
|
|
XCTAssertEqual(obj.propA, 2);
|
|
XCTAssertEqualObjects(obj.propB, @"b");
|
|
|
|
// Verify that they're all readable via the other class
|
|
RLMResults<RenamedProperties2 *> *results = [RenamedProperties2 allObjectsInRealm:realm];
|
|
XCTAssertEqual(results[0].propC, 1);
|
|
XCTAssertEqualObjects(results[0].propD, @"a");
|
|
XCTAssertEqual(results[1].propC, 2);
|
|
XCTAssertEqualObjects(results[1].propD, @"b");
|
|
XCTAssertEqual(results[2].propC, 2);
|
|
XCTAssertEqualObjects(results[2].propD, @"b");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
#pragma mark - Create Or Update
|
|
|
|
- (void)testCreateOrUpdateWithoutPKThrows {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrowsWithReason([DogObject createOrUpdateInRealm:realm withValue:@[]],
|
|
@"'DogObject' does not have a primary key");
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateUpdatesExistingItemWithSamePK {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto so = [PrimaryStringObject createOrUpdateInRealm:realm withValue:@[@"pk", @2]];
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(so.intCol, 2);
|
|
|
|
auto so2 = [PrimaryStringObject createOrUpdateInRealm:realm withValue:@[@"pk", @3]];
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(so.intCol, 3);
|
|
XCTAssertEqualObjects(so, so2);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateWithNullPrimaryKey {
|
|
RLMRealm *realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
[PrimaryNullableStringObject createOrUpdateInRealm:realm withValue:@{@"intCol": @5}];
|
|
[PrimaryNullableStringObject createOrUpdateInRealm:realm withValue:@{@"intCol": @7}];
|
|
XCTAssertEqual([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:NSNull.null].intCol, 7);
|
|
[PrimaryNullableStringObject createOrUpdateInRealm:realm withValue:@{@"stringCol": NSNull.null, @"intCol": @11}];
|
|
XCTAssertEqual([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:nil].intCol, 11);
|
|
|
|
[PrimaryNullableIntObject createOrUpdateInRealm:realm withValue:@{@"value": @5}];
|
|
[PrimaryNullableIntObject createOrUpdateInRealm:realm withValue:@{@"value": @7}];
|
|
XCTAssertEqual([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:NSNull.null].value, 7);
|
|
[PrimaryNullableIntObject createOrUpdateInRealm:realm withValue:@{@"optIntCol": NSNull.null, @"value": @11}];
|
|
XCTAssertEqual([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:nil].value, 11);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateDoesNotModifyKeysNotPresent {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto so = [PrimaryStringObject createOrUpdateInRealm:realm withValue:@[@"pk", @2]];
|
|
auto so2 = [PrimaryStringObject createOrUpdateInRealm:realm withValue:@{@"stringCol": @"pk"}];
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(so.intCol, 2);
|
|
XCTAssertEqual(so2.intCol, 2);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateDoesNotReplaceExistingValuesWithDefaults {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto so = [PrimaryKeyWithDefault createInRealm:realm withValue:@[@"pk", @2]];
|
|
[PrimaryKeyWithDefault createOrUpdateInRealm:realm withValue:@{@"stringCol": @"pk"}];
|
|
XCTAssertEqual(so.intCol, 2);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateReplacesExistingArrayPropertiesAndDoesNotMergeThem {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj = [AllLinksWithPrimary createInRealm:realm withValue:@[@"pk", @[@"str"],
|
|
@[@"str pk", @5],
|
|
@[@[@1], @[@2], @[@3]]]];
|
|
[AllLinksWithPrimary createOrUpdateInRealm:realm withValue:@[@"pk", @[@"str"],
|
|
@[@"str pk", @6],
|
|
@[@[@4]]]];
|
|
XCTAssertEqual(1U, obj.intArray.count);
|
|
XCTAssertEqual(4, obj.intArray[0].intCol);
|
|
XCTAssertEqual(6, obj.primaryString.intCol);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateReusesExistingLinkedObjectsWithPrimaryKeys {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
[AllLinksWithPrimary createInRealm:realm withValue:@[@"pk", NSNull.null,
|
|
@[@"str pk", @5]]];
|
|
[AllLinksWithPrimary createOrUpdateInRealm:realm withValue:@[@"pk", NSNull.null,
|
|
@{@"stringCol": @"str pk"}]];
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateCreatesNewLinkedObjectsWithoutPrimaryKeys {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
[AllLinksWithPrimary createInRealm:realm withValue:@[@"pk", @[@"str"]]];
|
|
[AllLinksWithPrimary createOrUpdateInRealm:realm withValue:@[@"pk", @[@"str"]]];
|
|
XCTAssertEqual(2U, [StringObject allObjectsInRealm:realm].count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateWithMissingValuesAndNoExistingObject {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrowsWithReason([PrimaryStringObject createOrUpdateInRealm:realm withValue:@{@"stringCol": @"pk"}],
|
|
@"Missing value for property 'PrimaryStringObject.intCol'");
|
|
RLMAssertThrowsWithReason(([PrimaryStringObject createOrUpdateInRealm:realm
|
|
withValue:@{@"stringCol": @"pk",
|
|
@"intCol": NSNull.null}]),
|
|
@"Invalid value '<null>' of type 'NSNull' for 'int' property 'PrimaryStringObject.intCol'");
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateOnManagedObjectInSameRealmReturnsExistingObjectInstance {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto so = [PrimaryStringObject createOrUpdateInRealm:realm withValue:@[@"pk", @2]];
|
|
auto so2 = [PrimaryStringObject createOrUpdateInRealm:realm withValue:so];
|
|
XCTAssertEqual(so, so2);
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateOnManagedObjectInDifferentRealmDeepCopies {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
auto realm2 = [self realmWithTestPath];
|
|
[realm2 beginWriteTransaction];
|
|
|
|
auto so = [StringObject createInRealm:realm withValue:@[@"str"]];
|
|
auto pso = [PrimaryStringObject createInRealm:realm withValue:@[@"pk", @1]];
|
|
auto io = [IntObject createInRealm:realm withValue:@[@2]];
|
|
auto pio = [PrimaryIntObject createInRealm:realm withValue:@[@3]];
|
|
|
|
auto links = [AllLinksWithPrimary createInRealm:realm withValue:@[@"pk", so, pso, @[io, io], @[pio, pio]]];
|
|
auto copy = [AllLinksWithPrimary createOrUpdateInRealm:realm2 withValue:links];
|
|
|
|
XCTAssertEqual(1U, [AllLinksWithPrimary allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(1U, [StringObject allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(2U, [IntObject allObjectsInRealm:realm2].count);
|
|
XCTAssertEqual(1U, [PrimaryIntObject allObjectsInRealm:realm2].count);
|
|
|
|
XCTAssertEqualObjects(so.stringCol, copy.string.stringCol);
|
|
XCTAssertEqualObjects(pso.stringCol, copy.primaryString.stringCol);
|
|
XCTAssertEqual(pso.intCol, copy.primaryString.intCol);
|
|
XCTAssertEqual(2U, copy.intArray.count);
|
|
XCTAssertEqual(2U, copy.primaryIntArray.count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
[realm2 cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateWithNilValues {
|
|
auto now = [NSDate date];
|
|
auto bytes = [NSData dataWithBytes:"a" length:1];
|
|
auto nonnull = [[AllOptionalTypesPK alloc] initWithValue:@[@0, @1, @2.2f, @3.3, @YES, @"a", bytes, now]];
|
|
auto null = [[AllOptionalTypesPK alloc] initWithValue:@[@0]];
|
|
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj = [AllOptionalTypesPK createInRealm:realm withValue:nonnull];
|
|
[AllOptionalTypesPK createOrUpdateInRealm:realm withValue:null];
|
|
|
|
XCTAssertNil(obj.intObj);
|
|
XCTAssertNil(obj.floatObj);
|
|
XCTAssertNil(obj.doubleObj);
|
|
XCTAssertNil(obj.boolObj);
|
|
XCTAssertNil(obj.string);
|
|
XCTAssertNil(obj.data);
|
|
XCTAssertNil(obj.date);
|
|
|
|
[AllOptionalTypesPK createOrUpdateInRealm:realm withValue:nonnull];
|
|
[AllOptionalTypesPK createOrUpdateInRealm:realm withValue:@[@0]];
|
|
|
|
// No values specified, so old values should remain
|
|
XCTAssertNotNil(obj.intObj);
|
|
XCTAssertNotNil(obj.floatObj);
|
|
XCTAssertNotNil(obj.doubleObj);
|
|
XCTAssertNotNil(obj.boolObj);
|
|
XCTAssertNotNil(obj.string);
|
|
XCTAssertNotNil(obj.data);
|
|
XCTAssertNotNil(obj.date);
|
|
|
|
[AllOptionalTypesPK createOrUpdateInRealm:realm withValue:@{@"pk": @0}];
|
|
XCTAssertNotNil(obj.intObj);
|
|
XCTAssertNotNil(obj.floatObj);
|
|
XCTAssertNotNil(obj.doubleObj);
|
|
XCTAssertNotNil(obj.boolObj);
|
|
XCTAssertNotNil(obj.string);
|
|
XCTAssertNotNil(obj.data);
|
|
XCTAssertNotNil(obj.date);
|
|
|
|
[AllOptionalTypesPK createOrUpdateInRealm:realm withValue:@{@"pk": @0,
|
|
@"intObj": NSNull.null,
|
|
@"floatObj": NSNull.null,
|
|
@"doubleObj": NSNull.null,
|
|
@"boolObj": NSNull.null,
|
|
@"string": NSNull.null,
|
|
@"data": NSNull.null,
|
|
@"date": NSNull.null,
|
|
}];
|
|
XCTAssertNil(obj.intObj);
|
|
XCTAssertNil(obj.floatObj);
|
|
XCTAssertNil(obj.doubleObj);
|
|
XCTAssertNil(obj.boolObj);
|
|
XCTAssertNil(obj.string);
|
|
XCTAssertNil(obj.data);
|
|
XCTAssertNil(obj.date);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testCreateOrUpdateWithRenamedPrimaryKey {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj = [RenamedPrimaryKey createInRealm:realm withValue:@[@1, @2]];
|
|
[RenamedPrimaryKey createOrUpdateInRealm:realm withValue:@[@1, @3]];
|
|
XCTAssertEqual(obj.pk, 1);
|
|
XCTAssertEqual(obj.value, 3);
|
|
|
|
[RenamedPrimaryKey createOrUpdateInRealm:realm withValue:@{@"pk": @1, @"value": @4}];
|
|
XCTAssertEqual(obj.value, 4);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
#pragma mark - Add
|
|
|
|
- (void)testAddInvalidated {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto dog = [DogObject createInRealm:realm withValue:@[@"name", @1]];
|
|
[realm deleteObject:dog];
|
|
RLMAssertThrowsWithReason([realm addObject:dog],
|
|
@"Adding a deleted or invalidated");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddDuplicatePrimaryKey {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
[realm addObject:[[PrimaryStringObject alloc] initWithValue:@[@"pk", @1]]];
|
|
RLMAssertThrowsWithReason(([realm addObject:[[PrimaryStringObject alloc] initWithValue:@[@"pk", @1]]]),
|
|
@"existing primary key value 'pk'");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddNested {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto co = [[CompanyObject alloc] initWithValue:@[@"one employee",
|
|
@[@[@"name", @2, @YES]]]];
|
|
[realm addObject:co];
|
|
XCTAssertEqual(co.realm, realm);
|
|
XCTAssertEqualObjects(co.name, @"one employee");
|
|
|
|
auto eo = co.employees[0];
|
|
XCTAssertEqual(eo.realm, realm);
|
|
XCTAssertEqualObjects(eo.name, @"name");
|
|
|
|
eo = [[EmployeeObject alloc] initWithValue:@[@"name 2", @3, @NO]];
|
|
co = [[CompanyObject alloc] initWithValue:@[@"one employee", @[eo]]];
|
|
|
|
[realm addObject:co];
|
|
XCTAssertEqual(co.realm, realm);
|
|
XCTAssertEqual(eo.realm, realm);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddingObjectWithoutAnyPropertiesThrows {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrows([realm addObject:[[AbstractObject alloc] initWithValue:@[]]]);
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddWithCustomAccessors {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto ca = [[CustomAccessorsObject alloc] initWithValue:@[@"a", @1]];
|
|
[realm addObject:ca];
|
|
XCTAssertEqualObjects(ca.name, @"a");
|
|
XCTAssertEqual(ca.age, 1);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddWithRenamedColumns {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj = [[RenamedProperties1 alloc] initWithValue:@[@1, @"a"]];
|
|
[realm addObject:obj];
|
|
XCTAssertEqual(obj.propA, 1);
|
|
XCTAssertEqualObjects(obj.propB, @"a");
|
|
|
|
RLMResults<RenamedProperties2 *> *results = [RenamedProperties2 allObjectsInRealm:realm];
|
|
XCTAssertEqual(results[0].propC, 1);
|
|
XCTAssertEqualObjects(results[0].propD, @"a");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddToCurrentRealmIsNoOp {
|
|
DogObject *dog = [[DogObject alloc] init];
|
|
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
[realm addObject:dog];
|
|
XCTAssertEqual(dog.realm, realm);
|
|
XCTAssertEqual(1U, [DogObject allObjectsInRealm:realm].count);
|
|
|
|
XCTAssertNoThrow([realm addObject:dog]);
|
|
XCTAssertEqual(dog.realm, realm);
|
|
XCTAssertEqual(1U, [DogObject allObjectsInRealm:realm].count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddToDifferentRealmThrows {
|
|
auto eo = [[EmployeeObject alloc] init];
|
|
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
[realm addObject:eo];
|
|
|
|
auto realm2 = [self realmWithTestPath];
|
|
[realm2 beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason([realm2 addObject:eo],
|
|
@"Object is already managed by another Realm. Use create instead to copy it into this Realm.");
|
|
XCTAssertEqual(eo.realm, realm);
|
|
|
|
auto co = [CompanyObject new];
|
|
[co.employees addObject:eo];
|
|
RLMAssertThrowsWithReason([realm2 addObject:co],
|
|
@"Object is already managed by another Realm. Use create instead to copy it into this Realm.");
|
|
XCTAssertEqual(co.realm, realm2);
|
|
|
|
[realm cancelWriteTransaction];
|
|
[realm2 cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddToCurrentRealmChecksForWrite {
|
|
DogObject *dog = [[DogObject alloc] init];
|
|
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
[realm addObject:dog];
|
|
[realm commitWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason([realm addObject:dog],
|
|
@"call beginWriteTransaction");
|
|
}
|
|
|
|
- (void)testAddObjectWithObserver {
|
|
DogObject *dog = [[DogObject alloc] init];
|
|
[dog addObserver:self forKeyPath:@"name" options:(NSKeyValueObservingOptions)0 context:0];
|
|
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrowsWithReason([realm addObject:dog],
|
|
@"Cannot add an object with observers to a Realm");
|
|
[realm cancelWriteTransaction];
|
|
[dog removeObserver:self forKeyPath:@"name"];
|
|
}
|
|
|
|
- (void)testAddObjectWithNilValueForRequiredProperty {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
RLMAssertThrowsWithReason([realm addObject:[[RequiredPropertiesObject alloc] init]],
|
|
@"Invalid value '<null>' of type 'NSNull' for 'string' property 'RequiredPropertiesObject.stringCol'.");
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
#pragma mark - Add Or Update
|
|
|
|
- (void)testAddOrUpdateWithoutPKThrows {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason([realm addOrUpdateObject:[DogObject new]],
|
|
@"'DogObject' does not have a primary key");
|
|
}
|
|
|
|
- (void)testAddOrUpdateUpdatesExistingItemWithSamePK {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
auto so1 = [[PrimaryStringObject alloc] initWithValue:@[@"pk", @2]];
|
|
auto so2 = [[PrimaryStringObject alloc] initWithValue:@[@"pk", @3]];
|
|
|
|
[realm addOrUpdateObject:so1];
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(so1.intCol, 2);
|
|
|
|
[realm addOrUpdateObject:so2];
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(so1.intCol, 3);
|
|
XCTAssertEqualObjects(so1, so2);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateWithNullPrimaryKey {
|
|
RLMRealm *realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
auto so1 = [[PrimaryNullableStringObject alloc] initWithValue:@{@"intCol": @5}];
|
|
auto so2 = [[PrimaryNullableStringObject alloc] initWithValue:@{@"intCol": @7}];
|
|
|
|
XCTAssertNil([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:NSNull.null]);
|
|
XCTAssertNil([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:nil]);
|
|
|
|
[realm addOrUpdateObject:so1];
|
|
XCTAssertEqual([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:NSNull.null].intCol, 5);
|
|
XCTAssertEqual([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:nil].intCol, 5);
|
|
|
|
[realm addOrUpdateObject:so2];
|
|
XCTAssertEqual([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:NSNull.null].intCol, 7);
|
|
XCTAssertEqual([PrimaryNullableStringObject objectInRealm:realm forPrimaryKey:nil].intCol, 7);
|
|
|
|
auto io1 = [[PrimaryNullableIntObject alloc] initWithValue:@{@"value": @5}];
|
|
auto io2 = [[PrimaryNullableIntObject alloc] initWithValue:@{@"value": @7}];
|
|
|
|
XCTAssertNil([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:NSNull.null]);
|
|
XCTAssertNil([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:nil]);
|
|
|
|
[realm addOrUpdateObject:io1];
|
|
XCTAssertEqual([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:NSNull.null].value, 5);
|
|
XCTAssertEqual([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:nil].value, 5);
|
|
|
|
[realm addOrUpdateObject:io2];
|
|
XCTAssertEqual([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:NSNull.null].value, 7);
|
|
XCTAssertEqual([PrimaryNullableIntObject objectInRealm:realm forPrimaryKey:nil].value, 7);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateDoesNotHaveAnyConceptOfKeysNotPresentThatShouldBeLeftAlone {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj1 = [[PrimaryKeyWithDefault alloc] initWithValue:@[@"pk", @2]];
|
|
auto obj2 = [[PrimaryKeyWithDefault alloc] initWithValue:@[@"pk"]];
|
|
[realm addOrUpdateObject:obj1];
|
|
[realm addOrUpdateObject:obj2];
|
|
XCTAssertEqual(obj1.intCol, 10);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddObjectWithNilValueForRequiredPropertyDoesNotUseExistingValue {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
[PrimaryKeyAndRequiredString createInRealm:realm withValue:@[@0, @"value"]];
|
|
RLMAssertThrowsWithReason([realm addOrUpdateObject:[[PrimaryKeyAndRequiredString alloc] init]],
|
|
@"Invalid value '<null>' of type 'NSNull' for 'string' property 'PrimaryKeyAndRequiredString.value'");
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateWithDuplicateConflictingValuesForPrimaryKeyInArrayProperty {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto company = [[PrimaryCompanyObject alloc] init];
|
|
[company.employees addObject:[[PrimaryEmployeeObject alloc] initWithValue:@[@"a", @1, @NO]]];
|
|
[company.employees addObject:[[PrimaryEmployeeObject alloc] initWithValue:@[@"a", @2, @NO]]];
|
|
[realm addOrUpdateObject:company];
|
|
|
|
XCTAssertEqual(1U, [PrimaryEmployeeObject allObjectsInRealm:realm].count);
|
|
XCTAssertEqual(2, company.employees[0].age);
|
|
XCTAssertEqual(2, company.employees[1].age);
|
|
XCTAssertEqualObjects(company.employees[0], company.employees[1]);
|
|
}
|
|
|
|
- (void)testAddOrUpdateReplacesExistingArrayPropertiesAndDoesNotMergeThem {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj1 = [[AllLinksWithPrimary alloc] initWithValue:@[@"pk", @[@"str"],
|
|
@[@"str pk", @5],
|
|
@[@[@1], @[@2], @[@3]]]];
|
|
auto obj2 = [[AllLinksWithPrimary alloc] initWithValue:@[@"pk", @[@"str"],
|
|
@[@"str pk", @6],
|
|
@[@[@4]]]];
|
|
[realm addOrUpdateObject:obj1];
|
|
[realm addOrUpdateObject:obj2];
|
|
XCTAssertEqual(1U, obj1.intArray.count);
|
|
XCTAssertEqual(4, obj1.intArray[0].intCol);
|
|
XCTAssertEqual(6, obj1.primaryString.intCol);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateReusesExistingLinkedObjectsWithPrimaryKeys {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj1 = [[AllLinksWithPrimary alloc] initWithValue:@[@"pk", NSNull.null,
|
|
@[@"str pk", @5]]];
|
|
auto obj2 = [[AllLinksWithPrimary alloc] initWithValue:@[@"pk", NSNull.null,
|
|
@{@"stringCol": @"str pk"}]];
|
|
|
|
[realm addOrUpdateObject:obj1];
|
|
[realm addOrUpdateObject:obj2];
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateAddsNewLinkedObjectsWithoutPrimaryKeys {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj1 = [[AllLinksWithPrimary alloc] initWithValue:@[@"pk", @[@"str"]]];
|
|
auto obj2 = [[AllLinksWithPrimary alloc] initWithValue:@[@"pk", @[@"str"]]];
|
|
|
|
[realm addOrUpdateObject:obj1];
|
|
[realm addOrUpdateObject:obj2];
|
|
XCTAssertEqual(2U, [StringObject allObjectsInRealm:realm].count);
|
|
XCTAssertFalse([obj1.string isEqualToObject:[StringObject allObjectsInRealm:realm][0]]);
|
|
XCTAssertTrue([obj1.string isEqualToObject:[StringObject allObjectsInRealm:realm][1]]);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateOnManagedObjectInSameRealmIsNoOp {
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto so = [PrimaryStringObject createOrUpdateInRealm:realm withValue:@[@"pk", @2]];
|
|
XCTAssertNoThrow([realm addOrUpdateObject:so]);
|
|
XCTAssertEqual(1U, [PrimaryStringObject allObjectsInRealm:realm].count);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateOnManagedObjectInDifferentRealmThrows {
|
|
auto eo = [[PrimaryEmployeeObject alloc] init];
|
|
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
[realm addObject:eo];
|
|
|
|
auto realm2 = [self realmWithTestPath];
|
|
[realm2 beginWriteTransaction];
|
|
|
|
RLMAssertThrowsWithReason([realm2 addOrUpdateObject:eo],
|
|
@"Object is already managed by another Realm. Use create instead to copy it into this Realm.");
|
|
XCTAssertEqual(eo.realm, realm);
|
|
|
|
auto co = [PrimaryCompanyObject new];
|
|
[co.employees addObject:eo];
|
|
RLMAssertThrowsWithReason([realm2 addOrUpdateObject:co],
|
|
@"Object is already managed by another Realm. Use create instead to copy it into this Realm.");
|
|
XCTAssertEqual(co.realm, realm2);
|
|
|
|
[realm cancelWriteTransaction];
|
|
[realm2 cancelWriteTransaction];
|
|
}
|
|
|
|
- (void)testAddOrUpdateWithNilValues {
|
|
auto now = [NSDate date];
|
|
auto bytes = [NSData dataWithBytes:"a" length:1];
|
|
auto nonnull = [[AllOptionalTypesPK alloc] initWithValue:@[@0, @1, @2.2f, @3.3, @YES, @"a", bytes, now]];
|
|
auto null = [[AllOptionalTypesPK alloc] initWithValue:@[@0]];
|
|
|
|
auto realm = [RLMRealm defaultRealm];
|
|
[realm beginWriteTransaction];
|
|
|
|
auto obj = [AllOptionalTypesPK createInRealm:realm withValue:nonnull];
|
|
auto nullobj = [[AllOptionalTypesPK alloc] initWithValue:null];
|
|
[realm addOrUpdateObject:nullobj];
|
|
|
|
XCTAssertNil(obj.intObj);
|
|
XCTAssertNil(obj.floatObj);
|
|
XCTAssertNil(obj.doubleObj);
|
|
XCTAssertNil(obj.boolObj);
|
|
XCTAssertNil(obj.string);
|
|
XCTAssertNil(obj.data);
|
|
XCTAssertNil(obj.date);
|
|
|
|
[realm cancelWriteTransaction];
|
|
}
|
|
|
|
@end
|
|
|