Пример #1
0
 def test_component_container_is_set_when_inserting_item_and_cleared_when_removing(
         self):
     ItemModel = Schema.entity("item", None, None,
                               {"flag": Schema.prop(Schema.BOOLEAN)})
     ContainerModel = Schema.entity(
         "c", None, None, {
             "c_items": Schema.array(Schema.component(ItemModel)),
             "r_items": Schema.array(Schema.reference(ItemModel)),
             "c_item": Schema.component(ItemModel),
             "r_item": Schema.reference(ItemModel),
         })
     context = Schema.SimpleEntityContext()
     c = ContainerModel.create(context)
     c._append_item("c_items", ItemModel.create())
     c._append_item("c_items", ItemModel.create())
     c._append_item("r_items", c._get_array_item("c_items", 0))
     c._append_item("r_items", c._get_array_item("c_items", 1))
     c._set_field_value("c_item", ItemModel.create())
     c._set_field_value("r_item", c.c_item)
     self.assertEqual(c, c._get_array_item("c_items", 0)._container)
     self.assertEqual(c, c._get_array_item("c_items", 1)._container)
     self.assertEqual(c, c._get_array_item("r_items", 0)._container)
     self.assertEqual(c, c._get_array_item("r_items", 1)._container)
     self.assertEqual(c, c._get_field_value("c_item")._container)
     self.assertEqual(c, c._get_field_value("r_item")._container)
     c_item0 = c._get_array_item("c_items", 0)
     c._remove_item("c_items", c_item0)
     self.assertIsNone(c_item0._container)
     c_item = c._get_field_value("c_item")
     c._set_field_value("c_item", None)
     self.assertIsNone(c_item._container)
Пример #2
0
 def test_setting_reference_before_context_works(self):
     ItemModel = Schema.entity("item", None, None,
                               {"flag": Schema.prop(Schema.BOOLEAN)})
     RefModel = Schema.entity("ref", None, None,
                              {"item": Schema.reference(ItemModel)})
     context = Schema.SimpleEntityContext()
     ref = RefModel.create()
     item = ItemModel.create()
     ref._set_field_value("item", item)
     self.assertEqual(
         item,
         ref._get_field_value("item"))  # check that the field value was set
     self.assertIsNone(item._entity_context
                       )  # setting the item should propagate the context
     ref._set_entity_context(context)
     self.assertEqual(
         item,
         ref._get_field_value("item"))  # check that the field value was set
     self.assertIsNone(
         item._entity_context
     )  # setting a reference item should NOT propagate the context
     ref._set_entity_context(None)
     self.assertEqual(
         item,
         ref._get_field_value("item"))  # check that the field value was set
     self.assertIsNone(item._entity_context
                       )  # setting the item should propagate the context
     ref._set_field_value("item", None)
     self.assertIsNone(ref._get_field_value("item"))
     self.assertIsNone(item._entity_context)  # context should be unset now
Пример #3
0
 def test_reference_is_initially_none(self):
     ItemModel = Schema.entity("item", None, None,
                               {"flag": Schema.prop(Schema.BOOLEAN)})
     RefModel = Schema.entity("ref", None, None,
                              {"item": Schema.reference(ItemModel)})
     ref = RefModel.create(Schema.SimpleEntityContext())
     self.assertIsNone(ref._get_field_value("item"))
Пример #4
0
    def test_setting_reference_triggers_property_changes_event(self):
        ItemModel = Schema.entity("item", None, None,
                                  {"flag": Schema.prop(Schema.BOOLEAN)})
        RefModel = Schema.entity("ref", None, None,
                                 {"item": Schema.reference(ItemModel)})
        context = Schema.SimpleEntityContext()
        ref = RefModel.create(context)
        item = ItemModel.create()
        changed = False

        def property_changed(name: str) -> None:
            nonlocal changed
            changed = True

        with contextlib.closing(
                ref.property_changed_event.listen(
                    property_changed)) as listener:
            ref._set_field_value("item", item)
            self.assertTrue(changed)
Пример #5
0
    def test_inserting_and_removing_array_components_and_references_trigger_events(
            self):
        ItemModel = Schema.entity("item", None, None,
                                  {"flag": Schema.prop(Schema.BOOLEAN)})
        ContainerModel = Schema.entity(
            "c", None, None, {
                "c_items": Schema.array(Schema.component(ItemModel)),
                "r_items": Schema.array(Schema.reference(ItemModel)),
            })
        context = Schema.SimpleEntityContext()
        c = ContainerModel.create(context)

        inserted_count = 0
        removed_count = 0

        def item_inserted(key: str, value, index: int) -> None:
            nonlocal inserted_count
            inserted_count += 1

        def item_removed(key: str, value, index: int) -> None:
            nonlocal removed_count
            removed_count += 1

        with contextlib.closing(c.item_inserted_event.listen(item_inserted)):
            with contextlib.closing(c.item_removed_event.listen(item_removed)):
                # test components
                c._append_item("c_items", ItemModel.create())
                c._append_item("c_items", ItemModel.create())
                self.assertEqual(2, inserted_count)
                self.assertEqual(0, removed_count)
                c._remove_item("c_items", c._get_array_item("c_items", 0))
                self.assertEqual(2, inserted_count)
                self.assertEqual(1, removed_count)
                # test references
                c._append_item("r_items", ItemModel.create())
                c._append_item("r_items", ItemModel.create())
                self.assertEqual(4, inserted_count)
                self.assertEqual(1, removed_count)
                c._remove_item("r_items", c._get_array_item("r_items", 0))
                self.assertEqual(4, inserted_count)
                self.assertEqual(2, removed_count)
Пример #6
0
 def test_inserting_and_removing_array_components_and_references_updates_contexts(
         self):
     ItemModel = Schema.entity("item", None, None,
                               {"flag": Schema.prop(Schema.BOOLEAN)})
     ContainerModel = Schema.entity(
         "c", None, None, {
             "c_items": Schema.array(Schema.component(ItemModel)),
             "r_items": Schema.array(Schema.reference(ItemModel)),
         })
     context = Schema.SimpleEntityContext()
     c = ContainerModel.create(context)
     # test component
     c_item = ItemModel.create()
     c._append_item("c_items", c_item)
     self.assertIsNotNone(c_item._entity_context)
     c._remove_item("c_items", c_item)
     self.assertIsNone(c_item._entity_context)
     # test reference
     c._append_item("r_items", c_item)
     r_item = c._get_array_item("r_items", 0)
     self.assertIsNone(r_item._entity_context
                       )  # setting a reference should NOT propagate context
     c._remove_item("r_items", c_item)
     self.assertIsNone(r_item._entity_context)
Пример #7
0
 def test_deepcopy(self):
     RecordModel = Schema.record({
         "value": Schema.prop(Schema.INT),
     })
     ItemModel = Schema.entity("item", None, None, {
         "name": Schema.prop(Schema.STRING),
         "record": RecordModel,
     })
     ListModel = Schema.entity(
         "list", None, None, {
             "c_items": Schema.array(Schema.component(ItemModel)),
             "r_items": Schema.array(Schema.reference(ItemModel)),
         })
     context = Schema.SimpleEntityContext()
     with contextlib.closing(ListModel.create(context)) as l:
         l._append_item(
             "c_items",
             ItemModel.create(None, {
                 "name": "aa",
                 "record": {
                     "value": 4
                 }
             }))
         l._append_item(
             "c_items",
             ItemModel.create(None, {
                 "name": "bb",
                 "record": {
                     "value": 5
                 }
             }))
         l._append_item("r_items", l._get_array_item("c_items", 0))
         l._append_item("r_items", l._get_array_item("c_items", 1))
         self.assertEqual(4, l._get_array_item("c_items", 0).record.value)
         self.assertEqual(5, l._get_array_item("c_items", 1).record.value)
         self.assertEqual(l._get_array_item("r_items", 0),
                          l._get_array_item("c_items", 0))
         self.assertEqual(l._get_array_item("r_items", 1),
                          l._get_array_item("c_items", 1))
         with contextlib.closing(copy.deepcopy(l)) as ll:
             self.assertEqual(
                 l._get_array_item("c_items", 0).uuid,
                 ll._get_array_item("c_items", 0).uuid)
             self.assertEqual(
                 l._get_array_item("c_items", 1).uuid,
                 ll._get_array_item("c_items", 1).uuid)
             self.assertEqual(
                 l._get_array_item("c_items", 0).modified,
                 ll._get_array_item("c_items", 0).modified)
             self.assertEqual(
                 l._get_array_item("c_items", 1).modified,
                 ll._get_array_item("c_items", 1).modified)
             self.assertEqual(
                 l._get_array_item("c_items", 0).name,
                 ll._get_array_item("c_items", 0).name)
             self.assertEqual(
                 l._get_array_item("c_items", 1).name,
                 ll._get_array_item("c_items", 1).name)
             self.assertEqual(4,
                              ll._get_array_item("c_items", 0).record.value)
             self.assertEqual(5,
                              ll._get_array_item("c_items", 1).record.value)
             self.assertEqual(ll._get_array_item("r_items", 0),
                              ll._get_array_item("c_items", 0))
             self.assertEqual(ll._get_array_item("r_items", 1),
                              ll._get_array_item("c_items", 1))
Пример #8
0
        "is_sequence": Schema.prop(Schema.BOOLEAN),
        "collection_dimension_count": Schema.prop(Schema.INT),
        "datum_dimension_count": Schema.prop(Schema.INT),
        "intensity_calibration": Calibration,
        "dimensional_calibrations": Schema.array(Calibration),
        "data_modified": Schema.prop(Schema.TIMESTAMP),
        "timezone": Schema.prop(Schema.STRING),
        "timezone_offset": Schema.prop(Schema.STRING),
        "metadata": Schema.prop(Schema.DICT),
        "title": Schema.prop(Schema.STRING),
        "caption": Schema.prop(Schema.STRING),
        "description": Schema.prop(Schema.STRING),
        "session_id": Schema.prop(Schema.STRING),
        "session": Schema.prop(Schema.DICT),
        "category": Schema.prop(Schema.STRING, default="persistent"),
        "source": Schema.reference(),
    })

DataItem.rename("source", "source_uuid")

DisplayAdjustment = Schema.entity("display_adjustment", None, None, {})

GammaDisplayAdjustment = Schema.entity("gamma", DisplayAdjustment, None, {
    "gamma": Schema.prop(Schema.FLOAT),
})

LogDisplayAdjustment = Schema.entity("log", DisplayAdjustment, None, {})

EqualizedDisplayAdjustment = Schema.entity("equalized", DisplayAdjustment,
                                           None, {})