public void Can_convert_ModelWithFieldsOfNullableTypes_of_nullables()
        {
            var model   = new ModelWithFieldsOfNullableTypes();
            var toModel = Serialize(model);

            ModelWithFieldsOfNullableTypes.AssertIsEqual(toModel, model);
        }
        public void Can_convert_ModelWithFieldsOfNullableTypes()
        {
            var model   = ModelWithFieldsOfNullableTypes.Create(1);
            var toModel = Serialize(model);

            ModelWithFieldsOfNullableTypes.AssertIsEqual(toModel, model);
        }
        public void Can_Convert_from_ObjectDictionary_with_Nullable_Properties(
            Dictionary <string, object> map,
            ModelWithFieldsOfNullableTypes expected)
        {
            var actual = map.FromObjectDictionary <ModelWithFieldsOfNullableTypes>();

            ModelWithFieldsOfNullableTypes.AssertIsEqual(actual, expected);
        }
Exemple #4
0
        public void Can_Serialize_empty_model_of_NullableTypes()
        {
            var model = new ModelWithFieldsOfNullableTypes();

            var json = JsonSerializer.SerializeToString(model);

            var fromJson = JsonSerializer.DeserializeFromString <ModelWithFieldsOfNullableTypes>(json);

            ModelWithFieldsOfNullableTypes.AssertIsEqual(model, fromJson);
        }
        public void Can_access_ModelWithFieldsOfDifferentAndNullableTypes()
        {
            var idAccessor       = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("Id");
            var idNAccessor      = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NId");
            var longIdAccessor   = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NLongId");
            var guidAccessor     = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NGuid");
            var boolAccessor     = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NBool");
            var dateTimeAccessor = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NDateTime");
            var floatAccessor    = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NFloat");
            var doubleAccessor   = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NDouble");
            var decimalAccessor  = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NDecimal");
            var timespanAccessor = new PropertyAccessor <ModelWithFieldsOfNullableTypes>("NTimeSpan");

            var original = ModelWithFieldsOfNullableTypesFactory.Instance.CreateInstance(1);

            Assert.That(idAccessor.GetPropertyFn()(original), Is.EqualTo(original.Id));
            Assert.That(idNAccessor.GetPropertyFn()(original), Is.EqualTo(original.NId));
            Assert.That(longIdAccessor.GetPropertyFn()(original), Is.EqualTo(original.NLongId));
            Assert.That(guidAccessor.GetPropertyFn()(original), Is.EqualTo(original.NGuid));
            Assert.That(boolAccessor.GetPropertyFn()(original), Is.EqualTo(original.NBool));
            Assert.That(dateTimeAccessor.GetPropertyFn()(original), Is.EqualTo(original.NDateTime));
            Assert.That(floatAccessor.GetPropertyFn()(original), Is.EqualTo(original.NFloat));
            Assert.That(doubleAccessor.GetPropertyFn()(original), Is.EqualTo(original.NDouble));
            Assert.That(decimalAccessor.GetPropertyFn()(original), Is.EqualTo(original.NDecimal));
            Assert.That(timespanAccessor.GetPropertyFn()(original), Is.EqualTo(original.NTimeSpan));

            var to = ModelWithFieldsOfNullableTypesFactory.Instance.CreateInstance(2);

            idAccessor.SetPropertyFn()(original, to.Id);
            idNAccessor.SetPropertyFn()(original, to.NId);
            longIdAccessor.SetPropertyFn()(original, to.NLongId);
            guidAccessor.SetPropertyFn()(original, to.NGuid);
            boolAccessor.SetPropertyFn()(original, to.NBool);
            dateTimeAccessor.SetPropertyFn()(original, to.NDateTime);
            floatAccessor.SetPropertyFn()(original, to.NFloat);
            doubleAccessor.SetPropertyFn()(original, to.NDouble);
            decimalAccessor.SetPropertyFn()(original, to.NDecimal);
            timespanAccessor.SetPropertyFn()(original, to.NTimeSpan);

            ModelWithFieldsOfNullableTypesFactory.Instance.AssertIsEqual(original, to);

            //Can handle nulls
            original = new ModelWithFieldsOfNullableTypes();

            Assert.That(idAccessor.GetPropertyFn()(original), Is.EqualTo(original.Id));
            Assert.That(idNAccessor.GetPropertyFn()(original), Is.EqualTo(original.NId));
            Assert.That(longIdAccessor.GetPropertyFn()(original), Is.EqualTo(original.NLongId));
            Assert.That(guidAccessor.GetPropertyFn()(original), Is.EqualTo(original.NGuid));
            Assert.That(boolAccessor.GetPropertyFn()(original), Is.EqualTo(original.NBool));
            Assert.That(dateTimeAccessor.GetPropertyFn()(original), Is.EqualTo(original.NDateTime));
            Assert.That(floatAccessor.GetPropertyFn()(original), Is.EqualTo(original.NFloat));
            Assert.That(doubleAccessor.GetPropertyFn()(original), Is.EqualTo(original.NDouble));
            Assert.That(decimalAccessor.GetPropertyFn()(original), Is.EqualTo(original.NDecimal));
            Assert.That(timespanAccessor.GetPropertyFn()(original), Is.EqualTo(original.NTimeSpan));
        }
        public void Can_insert_and_select_from_ModelWithFieldsOfNullableTypes_table()
        {
            using (var db = OpenDbConnection())
            {
                db.CreateTable <ModelWithFieldsOfNullableTypes>(true);

                var row = ModelWithFieldsOfNullableTypes.Create(1);

                db.Insert(row);

                var rows = db.Select <ModelWithFieldsOfNullableTypes>();

                Assert.That(rows, Has.Count.EqualTo(1));

                ModelWithFieldsOfNullableTypes.AssertIsEqual(rows[0], row);
            }
        }
        public void Can_insert_and_select_from_ModelWithFieldsOfNullableTypes_table()
        {
            using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
            {
                db.CreateTable <ModelWithFieldsOfNullableTypes>(true);

                var row = ModelWithFieldsOfNullableTypes.Create(1);

                db.Insert(row);

                var rows = db.Select <ModelWithFieldsOfNullableTypes>();

                Assert.That(rows, Has.Count.EqualTo(1));

                ModelWithFieldsOfNullableTypes.AssertIsEqual(rows[0], row);
            }
        }
Exemple #8
0
        public void Can_DeleteNonDefaults_entity_with_nullable_DateTime()
        {
            db.DropAndCreateTable <ModelWithFieldsOfNullableTypes>();

            var row = ModelWithFieldsOfNullableTypes.Create(1);

            row.NDateTime = null;

            db.Save(row);

            row = db.SingleById <ModelWithFieldsOfNullableTypes>(row.Id);

            var rowsAffected = db.DeleteNonDefaults(row);

            Assert.That(rowsAffected, Is.EqualTo(1));

            row = db.SingleById <ModelWithFieldsOfNullableTypes>(row.Id);
            Assert.That(row, Is.Null);
        }
Exemple #9
0
        public void Can_DeleteNonDefaultsAll_entity_with_nullable_DateTime()
        {
            db.DropAndCreateTable <ModelWithFieldsOfNullableTypes>();

            var rows = 3.Times(i => ModelWithFieldsOfNullableTypes.Create(i));

            rows.Each(x => x.NDateTime = null);

            db.SaveAll(rows);
            db.Save(ModelWithFieldsOfNullableTypes.Create(3)); // extra row shouldn't be deleted

            rows = db.SelectByIds <ModelWithFieldsOfNullableTypes>(rows.Map(x => x.Id));

            var rowsAffected = db.DeleteNonDefaults(rows.ToArray());

            Assert.That(rowsAffected, Is.EqualTo(rows.Count));

            rows = db.SelectByIds <ModelWithFieldsOfNullableTypes>(rows.Map(x => x.Id));
            Assert.That(rows.Count, Is.EqualTo(0));
        }