def test_create(self):
        """
        Test model creation behaviour.
        
        .. versionadded:: v00_02_00
        .. versionchanged:: 0.9.0
            Verify that created models have all read-only fields, etc populated with
            values from Shotgun.
        .. versionchanged:: 0.9.1
            Verify that it is possible to set read-only fields on models at creation time.
        .. versionchanged:: 0.11.0
            Update to use nose asserts statements.
        .. versionchanged:: 1.1.0
            Update to confirm that never_editable fields are ignored during creation.
        """
        # step 1: create a non-existant item
        result = self.model.create()
        assert_not_equals(result['id'], None)

        # step 2: attempt to recreate an existing item
        assert_raises(GrenadeModelCreateError, self.model.create)

        # step 3: verify that all fields are populated
        model = find(self.session, 'MockModel', [['id', 'is', 1]], [],
                     FIND_ONE)
        model.properties['id'].value = None  # cheat
        model.properties['field_three'].value = None  # cheat

        model.create()  # populates read-only fields, etc from shotgun

        assert_equals(model['field_three'], 99)

        # step 4: verify that we can set a read-only field at creation time
        model = find(self.session, 'MockModel', [['id', 'is', 1]], [],
                     FIND_ONE)
        model.properties['id'].value = None
        model['field_three'] = 3

        model.create()  # sets read-only fields to specified creation value

        assert_equals(model['field_three'], 3)

        # step 5: verify that never_editable fields are ignored at creation time
        model = Model(self.session, 'Task', None,
                      self.shotgun_schema[1]['Task'])
        model['field_one'] = 1
        model['dependency_violation'] = False
        assert_true(model.properties.has_key('dependency_violation'))

        result = model.create()  # should skip dependency_violation field

        assert_not_equals(result['id'], None)
        assert_equals(result['dependency_violation'],
                      True)  # confirm we got default
    def setup(self):
        """
        Set up the unit test suite.
        
        .. versionadded:: v00_02_00
        .. versionchanged:: v00_03_00
            Updated due to changes to model constructor, add the MockModel schema to the MockShotgun instance.
        .. versionchanged:: 0.9.0
            Update schema in order to allow testing of read-only field behaviour.
        .. versionchanged:: 0.11.0
            Set the starting id for the mock shotgun id generator.
        .. versionchanged:: 1.0.0
            Set the datatype and properties schema entries on fields that were missing these values. Added a
            new schema field and test data to allow testing that unsupported API data types are filtered out.
        .. versionchanged:: 1.1.0
            Added Task schema definition to aid testing of never_editable fields.
        """
        self.shotgun_data = [{
            'id': 1,
            'type': 'MockModel',
            'field_one': 1,
            'field_two': 2,
            'field_three': 3,
            'field_pivot': 'x'
        }, {
            'id': 2,
            'type': 'MockModel',
            'field_one': 1,
            'field_two': 2,
            'field_three': 3
        }, {
            'id': 3,
            'type': 'MockModel',
            'field_one': 3,
            'field_two': 2,
            'field_three': 1
        }]

        self.shotgun_schema = [{
            'MockModel': {
                'field_one': {
                    'data_type': {
                        'value': 'integer'
                    },
                    'properties': {}
                },
                'field_two': {
                    'data_type': {
                        'value': 'integer'
                    },
                    'properties': {}
                },
                'field_three': {
                    'data_type': {
                        'value': 'integer'
                    },
                    'editable': {
                        'value': False
                    },
                    'properties': {
                        'default_value': {
                            'value': 99
                        }
                    }
                }
            },
            'field_pivot': {
                'data_type': {
                    'value': 'pivot_column'
                }
            }
        }, {
            'Task': {
                'field_one': {},
                'dependency_violation': {
                    'data_type': {
                        'value': 'boolean'
                    },
                    'editable': {
                        'value': False
                    },
                    'properties': {
                        'default_value': {
                            'value': True
                        }
                    }
                }
            }
        }]

        self.session = MockShotgun(schema=self.shotgun_schema,
                                   data=self.shotgun_data,
                                   first_id=4)
        self.identifier = 'MockModel'
        self.translator = MockTranslator(self.session)

        self.model_schema = {
            'field_one': None,
            'field_two': None,
            'field_three': None
        }

        # manually build a model for this test
        self.model = Model(self.session, self.identifier, self.translator,
                           self.model_schema)

        self.model['field_one'] = 1
        self.model['field_two'] = 2
        self.model['field_three'] = 3

        self.model._purify()