| # Copyright 2017-present Open Networking Foundation |
| # |
| # 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. |
| |
| from __future__ import print_function |
| |
| import os |
| import random |
| import string |
| import sys |
| import unittest |
| |
| try: # python 3 |
| from io import StringIO |
| from unittest.mock import patch, MagicMock |
| except ImportError: # python 2 |
| from StringIO import StringIO |
| from mock import patch, MagicMock |
| |
| |
| # by default, use fake stub rather than real core |
| USE_FAKE_STUB = True |
| |
| PARENT_DIR = os.path.join(os.path.dirname(__file__), "..") |
| |
| |
| class ORMTestBaseClass(unittest.TestCase): |
| def setUp(self): |
| from xosconfig import Config |
| |
| test_path = os.path.abspath(os.path.dirname(os.path.realpath(__file__))) |
| config = os.path.join(test_path, "test_config.yaml") |
| Config.clear() |
| Config.init(config, "synchronizer-config-schema.yaml") |
| if USE_FAKE_STUB: |
| sys.path.append(PARENT_DIR) |
| |
| # Import these after config, in case they depend on config |
| from xosapi.orm import ORMQuerySet, ORMLocalObjectManager |
| |
| self.ORMQuerySet = ORMQuerySet |
| self.ORMLocalObjectManager = ORMLocalObjectManager |
| |
| self.orm = self.make_coreapi() |
| |
| def tearDown(self): |
| if USE_FAKE_STUB: |
| sys.path.remove(PARENT_DIR) |
| |
| def make_coreapi(self): |
| if USE_FAKE_STUB: |
| import xosapi.orm |
| from fake_stub import FakeStub, FakeProtos, FakeObj |
| |
| xosapi.orm.import_convenience_methods() |
| |
| stub = FakeStub() |
| api = xosapi.orm.ORMStub( |
| stub=stub, |
| package_name="xos", |
| protos=FakeProtos(), |
| empty=FakeObj, |
| enable_backoff=False, |
| ) |
| return api |
| else: |
| return xos_grpc_client.coreapi |
| |
| |
| class TestORMWrapper(ORMTestBaseClass): |
| """ Tests for the ORMWrapper class """ |
| |
| def test_ORMWrapper_fields_differ(self): |
| testModel = self.orm.TestModel(intfield=7, stringfield="foo") |
| self.assertTrue(testModel.fields_differ("a", "b")) |
| self.assertFalse(testModel.fields_differ("a", "a")) |
| |
| def test_ORMWrapper_dict(self): |
| testModel = self.orm.TestModel(intfield=7, stringfield="foo") |
| |
| self.assertDictEqual(testModel._dict, {"intfield": 7, "stringfield": "foo"}) |
| |
| def test_ORMWrapper_new_diff(self): |
| site = self.orm.Site(name="mysite") |
| |
| self.assertEqual(site.is_new, True) |
| self.assertEqual(site._dict, {"name": "mysite"}) |
| self.assertEqual(site.diff, {}) |
| self.assertEqual(site.changed_fields, ["name"]) |
| self.assertEqual(site.has_field_changed("name"), False) |
| self.assertEqual(site.has_field_changed("login_base"), False) |
| self.assertEqual(site.has_changed, False) |
| |
| site.login_base = "bar" |
| |
| self.assertEqual(site._dict, {"login_base": "bar", "name": "mysite"}) |
| self.assertEqual(site.diff, {"login_base": (None, "bar")}) |
| self.assertIn("name", site.changed_fields) |
| self.assertIn("login_base", site.changed_fields) |
| self.assertEqual(site.has_field_changed("name"), False) |
| self.assertEqual(site.has_field_changed("login_base"), True) |
| self.assertEqual(site.has_changed, True) |
| self.assertEqual(site.get_field_diff("login_base"), (None, "bar")) |
| |
| def test_ORMWrapper_existing_diff(self): |
| site = self.orm.Site(name="mysite", login_base="foo") |
| site.save() |
| site = self.orm.Site.objects.first() |
| |
| self.assertEqual(site.is_new, False) |
| self.assertEqual(site._dict, {"id": 1, "name": "mysite", "login_base": "foo"}) |
| self.assertEqual(site.diff, {}) |
| self.assertEqual(site.changed_fields, []) |
| self.assertEqual(site.has_field_changed("name"), False) |
| self.assertEqual(site.has_field_changed("login_base"), False) |
| self.assertEqual(site.has_changed, False) |
| |
| site.login_base = "bar" |
| |
| self.assertEqual(site._dict, {"id": 1, "login_base": "bar", "name": "mysite"}) |
| self.assertEqual(site.diff, {"login_base": ("foo", "bar")}) |
| self.assertIn("login_base", site.changed_fields) |
| self.assertEqual(site.has_field_changed("name"), False) |
| self.assertEqual(site.has_field_changed("login_base"), True) |
| self.assertEqual(site.has_changed, True) |
| |
| def test_ORMWrapper_diff_after_save(self): |
| site = self.orm.Site(name="mysite", login_base="foo") |
| site.save() |
| site = self.orm.Site.objects.first() |
| |
| self.assertEqual(site.diff, {}) |
| |
| site.login_base = "bar" |
| |
| self.assertEqual(site.diff, {"login_base": ("foo", "bar")}) |
| |
| site.save() |
| |
| self.assertEqual(site.diff, {}) |
| |
| def test_ORMWrapper_recompute_initial(self): |
| """ For saved models, Recompute_initial should take recompute the set of initial values, removing all items |
| from the diff set. |
| """ |
| |
| testModel = self.orm.TestModel() |
| testModel.save() |
| |
| testModel.intfield = 9 |
| self.assertEqual(testModel.changed_fields, ["intfield"]) |
| |
| testModel.recompute_initial() |
| self.assertEqual(testModel.changed_fields, []) |
| |
| def test_ORMWrapper_save_changed_fields(self): |
| testModel = self.orm.TestModel(intfield=7, stringfield="foo") |
| testModel.save() |
| |
| testModel.intfield = 9 |
| |
| with patch.object( |
| self.orm.grpc_stub, "UpdateTestModel", wraps=self.orm.grpc_stub.UpdateTestModel |
| ) as update: |
| testModel.save_changed_fields() |
| |
| self.assertEqual(update.call_count, 1) |
| self.assertIn("metadata", update.call_args[1]) |
| update_fields_arg = [ |
| x[1] for x in update.call_args[1]["metadata"] if x[0] == "update_fields" |
| ] |
| self.assertEqual(update_fields_arg, ["intfield"]) |
| |
| def test_ORMWrapper_create_attr(self): |
| testModel = self.orm.TestModel() |
| testModel.create_attr("some_new_attribute", "foo") |
| self.assertEqual(testModel.some_new_attribute, "foo") |
| |
| def test_ORMWrapper_get_generic_foreignkeys(self): |
| """ Currently this is a placeholder that returns an empty list """ |
| |
| testModel = self.orm.TestModel() |
| self.assertEqual(testModel.get_generic_foreignkeys(), []) |
| |
| def test_ORMWrapper_gen_fkmap(self): |
| """ TestModelTwo includes a foreignkey relation to TestModel, and the fkmap should contain that relation """ |
| |
| testModelTwo = self.orm.TestModelTwo() |
| |
| self.assertDictEqual( |
| testModelTwo.gen_fkmap(), |
| { |
| "testmodel": { |
| "kind": "fk", |
| "modelName": "TestModel", |
| "reverse_fieldName": "testmodeltwos", |
| "src_fieldName": "testmodel_id", |
| } |
| }, |
| ) |
| |
| def test_ORMWrapper_gen_reverse_fkmap(self): |
| """ TestModel includes a reverse relation back to TestModelTwo, and the reverse_fkmap should contain that |
| relation. |
| """ |
| |
| testModel = self.orm.TestModel() |
| |
| self.assertDictEqual( |
| testModel.gen_reverse_fkmap(), |
| { |
| "testmodeltwos": { |
| "modelName": "TestModelTwo", |
| "src_fieldName": "testmodeltwos_ids", |
| "writeable": False, |
| } |
| }, |
| ) |
| |
| def test_ORMWrapper_fk_resolve(self): |
| """ If we create a TestModelTwo that has a foreign key reference to a TestModel, then calling fk_resolve should |
| return that model. |
| """ |
| |
| testModel = self.orm.TestModel() |
| testModel.save() |
| |
| testModelTwo = self.orm.TestModelTwo(testmodel_id=testModel.id) |
| |
| testModel_resolved = testModelTwo.fk_resolve("testmodel") |
| self.assertEqual(testModel_resolved.id, testModel.id) |
| |
| # the cache should have been populated |
| self.assertIn(("testmodel", testModel_resolved), testModelTwo.cache.items()) |
| |
| def test_ORMWrapper_reverse_fk_resolve(self): |
| """ If a TestModelTwo has a relation to TestModel, then TestModel's reverse_fk should be resolvable to a list |
| of TestModelTwo objects. |
| """ |
| |
| testModel = self.orm.TestModel() |
| testModel.save() |
| |
| testModelTwo = self.orm.TestModelTwo(testmodel_id=testModel.id) |
| testModelTwo.save() |
| |
| # fake_stub.py doesn't populate the reverse relations for us, so force what the server would have done... |
| testModel._wrapped_class.testmodeltwos_ids = [testModelTwo.id] |
| |
| testModelTwos_resolved = testModel.reverse_fk_resolve("testmodeltwos") |
| self.assertEqual(testModelTwos_resolved.count(), 1) |
| |
| # the reverse_cache should have been populated |
| self.assertIn( |
| ("testmodeltwos", testModelTwos_resolved), testModel.reverse_cache.items() |
| ) |
| |
| def test_ORMWrapper_fk_set(self): |
| """ fk_set will set the testmodel field on TesTModelTwo to point to the TestModel. """ |
| |
| testModel = self.orm.TestModel() |
| testModel.save() |
| |
| testModelTwo = self.orm.TestModelTwo() |
| |
| testModelTwo.fk_set("testmodel", testModel) |
| |
| self.assertEqual(testModelTwo.testmodel_id, testModel.id) |
| |
| def test_ORMWrapper_post_save_fixups_remove(self): |
| """ Apply a post_save_fixup that removes a reverse foreign key """ |
| |
| testModel = self.orm.TestModel() |
| testModel.save() |
| |
| testModelTwo = self.orm.TestModelTwo(testmodel_id=testModel.id) |
| |
| # fake_stub.py doesn't populate the reverse relations for us, so force what the server would have done... |
| testModel._wrapped_class.testmodeltwos_ids = [testModelTwo.id] |
| |
| post_save_fixups = [ |
| { |
| "src_fieldName": "testmodel", |
| "dest_id": None, # this field appears to not be used... |
| "dest_model": testModel, |
| "remove": True, |
| "reverse_fieldName": "testmodeltwos", |
| } |
| ] |
| |
| testModelTwo.post_save_fixups = post_save_fixups |
| testModelTwo.do_post_save_fixups() |
| |
| self.assertEqual(testModel._wrapped_class.testmodeltwos_ids, []) |
| |
| def test_ORMWrapper_post_save_fixups_add(self): |
| """ Apply a post_save_fixup that adds a reverse foreign key """ |
| |
| testModel = self.orm.TestModel() |
| testModel.save() |
| |
| testModelTwo = self.orm.TestModelTwo(testmodel_id=testModel.id) |
| testModelTwo.save() |
| |
| # Make sure the reverse_relation is unpopulated. This should be the case, as fake_stub.py() doesn't populate |
| # the reverse relation. But let's be sure, in case someone fixes that. |
| testModel._wrapped_class.testmodeltwos_ids = [] |
| |
| post_save_fixups = [ |
| { |
| "src_fieldName": "testmodel", |
| "dest_id": None, # this field appears to not be used... |
| "dest_model": testModel, |
| "remove": False, |
| "reverse_fieldName": "testmodeltwos", |
| } |
| ] |
| |
| testModelTwo.post_save_fixups = post_save_fixups |
| testModelTwo.do_post_save_fixups() |
| |
| self.assertEqual(testModel._wrapped_class.testmodeltwos_ids, [testModelTwo.id]) |
| |
| def test_ORMWrapper_tologdict(self): |
| """ Tologdict contains the model name and id, used for structured logging """ |
| testModel = self.orm.TestModel(intfield=7, stringfile="foo") |
| |
| self.assertDictEqual( |
| testModel.tologdict(), {"model_name": "TestModel", "pk": 0} |
| ) |
| |
| def test_repr_name(self): |
| s = self.orm.Slice(name="foo") |
| self.assertNotEqual(s, None) |
| self.assertEqual(repr(s), "<Slice: foo>") |
| |
| def test_repr_noname(self): |
| s = self.orm.Slice() |
| self.assertNotEqual(s, None) |
| self.assertEqual(repr(s), "<Slice: id-0>") |
| |
| def test_str_name(self): |
| s = self.orm.Slice(name="foo") |
| self.assertNotEqual(s, None) |
| self.assertEqual(str(s), "foo") |
| |
| def test_str_noname(self): |
| s = self.orm.Slice() |
| self.assertNotEqual(s, None) |
| self.assertEqual(str(s), "Slice-0") |
| |
| def test_dumpstr_name(self): |
| s = self.orm.Slice(name="foo") |
| self.assertNotEqual(s, None) |
| self.assertEqual(s.dumpstr(), 'name: "foo"\n') |
| |
| def test_dumpstr_noname(self): |
| s = self.orm.Slice() |
| self.assertNotEqual(s, None) |
| self.assertEqual(s.dumpstr(), "") |
| |
| def test_dump(self): |
| """ dump() is like dumpstr() but prints to stdout. Mock stdout by using a stringIO. """ |
| |
| s = self.orm.Slice(name="foo") |
| self.assertNotEqual(s, None) |
| with patch("sys.stdout", new_callable=StringIO) as mock_stdout: |
| s.dump() |
| self.assertEqual(mock_stdout.getvalue(), 'name: "foo"\n\n') |
| |
| def test_invalidate_cache(self): |
| testModel = self.orm.TestModel() |
| |
| # populate the caches with some placeholders we can test for |
| testModel.cache = {"a": 1} |
| testModel.reverse_cache = {"b": 2} |
| |
| testModel.invalidate_cache() |
| |
| self.assertEqual(testModel.cache, {}) |
| self.assertEqual(testModel.reverse_cache, {}) |
| |
| def test_leaf_model_trivial(self): |
| service = self.orm.Service(name="myservice") |
| service.save() |
| self.assertEqual(service.leaf_model_name, "Service") |
| |
| def test_leaf_model_descendant(self): |
| onos_service = self.orm.ONOSService(name="myservice") |
| onos_service.save() |
| self.assertEqual(onos_service.model_name, "ONOSService") |
| self.assertEqual(onos_service.leaf_model_name, "ONOSService") |
| |
| service = self.orm.Service.objects.get(id=onos_service.id) |
| self.assertEqual(service.id, onos_service.id) |
| self.assertEqual(service.model_name, "Service") |
| self.assertEqual(service.leaf_model_name, "ONOSService") |
| |
| onos_service_cast = service.leaf_model |
| self.assertEqual(onos_service_cast.model_name, "ONOSService") |
| self.assertEqual(onos_service_cast.leaf_model_name, "ONOSService") |
| self.assertEqual(onos_service_cast.id, onos_service.id) |
| |
| def test_ORMWrapper_model_name(self): |
| testModel = self.orm.TestModel() |
| self.assertEqual(testModel.model_name, "TestModel") |
| |
| def test_ORMWrapper_ansible_tag(self): |
| """ Ansible_tag is used by old-style synchronizers. Deprecated. """ |
| |
| testModel = self.orm.TestModel(id=7) |
| |
| self.assertEqual(testModel.ansible_tag, "TestModel_7") |
| |
| |
| class TestORMQuerySet(ORMTestBaseClass): |
| """ Tests for high-level ORMQuerySet class """ |
| |
| def test_ORMQuerySet_first_nonempty(self): |
| qs = self.ORMQuerySet([1, 2, 3]) |
| self.assertEqual(qs.first(), 1) |
| |
| def test_ORMQuerySet_first_empty(self): |
| qs = self.ORMQuerySet([]) |
| self.assertEqual(qs.first(), None) |
| |
| def test_ORMQuerySet_exists_nonempty(self): |
| qs = self.ORMQuerySet([1, 2, 3]) |
| self.assertEqual(qs.exists(), True) |
| |
| def test_ORMQuerySet_exists_empty(self): |
| qs = self.ORMQuerySet() |
| self.assertEqual(qs.exists(), False) |
| |
| |
| class TestORMLocalObjectManager(ORMTestBaseClass): |
| """ Tests for high-level ORMLocalObjectManager class """ |
| |
| def test_ORMLocalObjectManager_nonempty(self): |
| """ Test all(), first(), exists(), and count() together since they're all closely related. Use a nonempty |
| list. |
| """ |
| t = self.orm.TestModel() |
| t.save() |
| |
| lobjs = self.ORMLocalObjectManager(t.stub, "TestModel", [t.id], False) |
| self.assertEqual(len(lobjs.all()), 1) |
| self.assertEqual(lobjs.all()[0].id, t.id) |
| self.assertEqual(lobjs.exists(), True) |
| self.assertEqual(lobjs.count(), 1) |
| self.assertEqual(lobjs.first().id, t.id) |
| |
| def test_ORMLocalObjectManager_empty(self): |
| """ Test all(), first(), exists(), and count() together since they're all closely related. Use an empty |
| list. |
| """ |
| t = self.orm.TestModel() |
| t.save() |
| |
| lobjs = self.ORMLocalObjectManager(t.stub, "TestModel", [], False) |
| self.assertEqual(len(lobjs.all()), 0) |
| self.assertEqual(lobjs.exists(), False) |
| self.assertEqual(lobjs.count(), 0) |
| self.assertEqual(lobjs.first(), None) |
| |
| def test_ORMLocalObjectManager_not_writeable(self): |
| """ An ORMLocalObjectManager that is not writeable should throw exceptions on add() and remove() """ |
| t = self.orm.TestModel() |
| t.save() |
| |
| lobjs = self.ORMLocalObjectManager(t.stub, "TestModel", [t.id], False) |
| |
| with self.assertRaises(Exception) as e: |
| lobjs.add(123) |
| self.assertEqual(str(e.exception), "Only ManyToMany lists are writeable") |
| |
| with self.assertRaises(Exception) as e: |
| lobjs.remove(123) |
| self.assertEqual(str(e.exception), "Only ManyToMany lists are writeable") |
| |
| def test_ORMLocalObjectManager_add(self): |
| t = self.orm.TestModel() |
| t.save() |
| |
| lobjs = self.ORMLocalObjectManager(t.stub, "TestModel", [], True) |
| lobjs.add(t) |
| self.assertEqual(lobjs.count(), 1) |
| self.assertEqual(lobjs.first().id, t.id) |
| |
| def test_ORMLocalObjectManager_remove(self): |
| t = self.orm.TestModel() |
| t.save() |
| |
| lobjs = self.ORMLocalObjectManager(t.stub, "TestModel", [t.id], True) |
| lobjs.remove(t) |
| self.assertEqual(lobjs.count(), 0) |
| |
| |
| class TestORMObjectManager(ORMTestBaseClass): |
| """ Tests for ORMObjectManager class """ |
| |
| def test_wrap_single(self): |
| wrapped_obj = self.orm.all_grpc_classes["Site"](name="mysite") |
| orm_obj = self.orm.Site.objects.wrap_single(wrapped_obj) |
| self.assertEqual(orm_obj._wrapped_class, wrapped_obj) |
| |
| def test_wrap_list(self): |
| wrapped_obj = self.orm.all_grpc_classes["Site"](name="mysite") |
| wrapped_list = MagicMock(items=[wrapped_obj]) |
| orm_objs = self.orm.Site.objects.wrap_list(wrapped_list) |
| self.assertEqual(len(orm_objs), 1) |
| self.assertEqual(orm_objs[0]._wrapped_class, wrapped_obj) |
| |
| def test_objects_all(self): |
| orig_len_sites = len(self.orm.Site.objects.all()) |
| site = self.orm.Site(name="mysite") |
| site.save() |
| sites = self.orm.Site.objects.all() |
| self.assertEqual(len(sites), orig_len_sites + 1) |
| |
| def test_objects_first(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| site = self.orm.Site.objects.first() |
| self.assertNotEqual(site, None) |
| |
| def test_filter_query_iexact(self): |
| with patch.object(self.orm.grpc_stub, "FilterTestModel", autospec=True) as filter: |
| self.orm.TestModel.objects.filter(name__iexact="foo") |
| self.assertEqual(filter.call_count, 1) |
| q = filter.call_args[0][0] |
| |
| self.assertEqual(q.kind, q.DEFAULT) |
| self.assertEqual(len(q.elements), 1) |
| self.assertEqual(q.elements[0].operator, q.elements[0].IEXACT) |
| self.assertEqual(q.elements[0].sValue, "foo") |
| |
| def test_filter_query_equal(self): |
| with patch.object(self.orm.grpc_stub, "FilterTestModel", autospec=True) as filter: |
| self.orm.TestModel.objects.filter(name="foo") |
| self.assertEqual(filter.call_count, 1) |
| q = filter.call_args[0][0] |
| |
| self.assertEqual(q.kind, q.DEFAULT) |
| self.assertEqual(len(q.elements), 1) |
| self.assertEqual(q.elements[0].operator, q.elements[0].EQUAL) |
| self.assertEqual(q.elements[0].sValue, "foo") |
| |
| def test_filter_special(self): |
| with patch.object(self.orm.grpc_stub, "FilterTestModel", autospec=True) as filter: |
| self.orm.TestModel.objects.filter_special(kind=self.orm.TestModel.objects.SYNCHRONIZER_DIRTY_OBJECTS) |
| self.assertEqual(filter.call_count, 1) |
| q = filter.call_args[0][0] |
| self.assertEqual(q.kind, q.SYNCHRONIZER_DIRTY_OBJECTS) |
| |
| def test_get(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| got_site = self.orm.Site.objects.get(id=site.id) |
| self.assertNotEqual(got_site, None) |
| self.assertEqual(got_site.id, site.id) |
| |
| def test_new(self): |
| site = self.orm.Site.objects.new(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| |
| |
| class TestORMModelClass(ORMTestBaseClass): |
| """ Tests for ORMModelClass class """ |
| |
| def test_name(self): |
| self.assertEqual(self.orm.Site.__name__, "Site") |
| |
| def test_content_type_id(self): |
| self.assertNotEqual(self.orm.Site.content_type_id, None) |
| |
| def test_call(self): |
| new_obj = self.orm.Site(name="mysite") |
| self.assertNotEqual(new_obj, None) |
| self.assertEqual(new_obj.name, "mysite") |
| |
| |
| class TestORM(ORMTestBaseClass): |
| """ Tests for OMRStub and misc high-level ORM operations """ |
| |
| def test_add_default_metadata(self): |
| md = [] |
| self.orm.add_default_metadata(md) |
| self.assertListEqual(md, [('caller_kind', 'grpcapi')]) |
| |
| def test_make_ID(self): |
| id_proto = self.orm.make_ID(123) |
| self.assertEqual(id_proto.id, 123) |
| |
| def test_make_empty(self): |
| empty_proto = self.orm.make_empty() |
| self.assertNotEqual(empty_proto, None) |
| |
| def test_make_Query(self): |
| query_proto = self.orm.make_Query() |
| self.assertNotEqual(query_proto, None) |
| self.assertTrue(hasattr(query_proto, "elements")) |
| |
| def test_listObjects(self): |
| objs = self.orm.listObjects() |
| self.assertIn("Slice", objs) |
| |
| def test_create(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| |
| def test_save_existing(self): |
| orig_len_sites = len(self.orm.Site.objects.all()) |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| |
| # there should be one new site |
| self.assertEqual(len(self.orm.Site.objects.all()), orig_len_sites + 1) |
| |
| # retrieve the site, and update it |
| created_site_id = site.id |
| site = self.orm.Site.objects.get(id=created_site_id) |
| site.name = "mysitetwo" |
| site.save() |
| |
| # the site_id should not have changed |
| self.assertEqual(site.id, created_site_id) |
| |
| # there should still be only one new site |
| self.assertEqual(len(self.orm.Site.objects.all()), orig_len_sites + 1) |
| |
| # the name should have changed |
| self.assertEqual(self.orm.Site.objects.get(id=created_site_id).name, "mysitetwo") |
| |
| def test_delete(self): |
| orig_len_sites = len(self.orm.Site.objects.all()) |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| site.delete() |
| sites = self.orm.Site.objects.all() |
| self.assertEqual(len(sites), orig_len_sites) |
| |
| def test_content_type_map(self): |
| self.assertTrue("Slice" in self.orm.content_type_map.values()) |
| self.assertTrue("Site" in self.orm.content_type_map.values()) |
| self.assertTrue("Tag" in self.orm.content_type_map.values()) |
| |
| def test_foreign_key_get(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| slice = self.orm.Slice(name="mysite_foo", site_id=site.id, creator_id=user.id) |
| slice.save() |
| self.assertTrue(slice.id > 0) |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site.id) |
| |
| def test_foreign_key_set_with_invalidate(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| slice = self.orm.Slice(name="mysite_foo", site=site, creator_id=user.id) |
| slice.save() |
| slice.invalidate_cache() |
| self.assertTrue(slice.id > 0) |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| |
| def test_foreign_key_set_without_invalidate(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| slice = self.orm.Slice(name="mysite_foo", site=site, creator_id=user.id) |
| slice.save() |
| self.assertTrue(slice.id > 0) |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| ids_from_models = [x.id for x in slice.site.slices.all()] |
| self.assertTrue(slice.id in ids_from_models) |
| |
| def test_foreign_key_reset(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| slice = self.orm.Slice(name="mysite_foo", site=site, creator_id=user.id) |
| slice.save() |
| self.assertTrue(slice.id > 0) |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id in site.slices_ids) |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| |
| site2 = self.orm.Site(name="mysite2") |
| site2.save() |
| slice.name = "mysite2_foo" |
| slice.site = site2 |
| slice.save() |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site2.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id not in site.slices_ids) |
| self.assertTrue(slice.id in site2.slices_ids) |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| ids_from_models1 = [x.id for x in site.slices.all()] |
| self.assertTrue(slice.id not in ids_from_models1) |
| ids_from_models2 = [x.id for x in site2.slices.all()] |
| self.assertTrue(slice.id in ids_from_models2) |
| |
| def test_foreign_key_back_and_forth_even(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| slice = self.orm.Slice(name="mysite_foo", site=site, creator_id=user.id) |
| slice.save() |
| self.assertTrue(slice.id > 0) |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id in site.slices_ids) |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| |
| site2 = self.orm.Site(name="mysite2") |
| site2.save() |
| slice.name = "mysite2_foo" |
| slice.site = site2 |
| slice.site = site |
| slice.site = site2 |
| slice.site = site |
| slice.save() |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id not in site2.slices_ids) |
| self.assertTrue(slice.id in site.slices_ids) |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| |
| def test_foreign_key_back_and_forth_odd(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| slice = self.orm.Slice(name="mysite_foo", site=site, creator_id=user.id) |
| slice.save() |
| self.assertTrue(slice.id > 0) |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id in site.slices_ids) |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| |
| site2 = self.orm.Site(name="mysite2") |
| site2.save() |
| slice.name = "mysite2_foo" |
| slice.site = site2 |
| slice.site = site |
| slice.site = site2 |
| slice.site = site |
| slice.site = site2 |
| slice.save() |
| self.assertNotEqual(slice.site, None) |
| self.assertEqual(slice.site.id, site2.id) |
| if not USE_FAKE_STUB: |
| self.assertTrue(slice.id not in site.slices_ids) |
| self.assertTrue(slice.id in site2.slices_ids) |
| self.assertTrue(slice.id in slice.site.slices_ids) |
| |
| def test_foreign_key_create_null(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| slice = self.orm.Slice( |
| name="mysite_foo", site=site, service=None, creator_id=user.id |
| ) |
| slice.save() |
| slice.invalidate_cache() |
| self.assertTrue(slice.id > 0) |
| self.assertEqual(slice.service, None) |
| |
| def test_foreign_key_set_null(self): |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| user = self.orm.User( |
| email="fake_" |
| + "".join( |
| random.choice(string.ascii_uppercase + string.digits) for _ in range(10) |
| ), |
| site_id=site.id, |
| ) |
| user.save() |
| self.assertTrue(user.id > 0) |
| service = self.orm.Service(name="myservice") |
| service.save() |
| self.assertTrue(service.id > 0) |
| # start out slice.service is non-None |
| slice = self.orm.Slice( |
| name="mysite_foo", site=site, service=service, creator_id=user.id |
| ) |
| slice.save() |
| slice.invalidate_cache() |
| self.assertTrue(slice.id > 0) |
| self.assertNotEqual(slice.service, None) |
| self.assertEqual(slice.service.id, service.id) |
| # now set it to None |
| slice.service = None |
| slice.save() |
| slice.invalidate_cache() |
| self.assertEqual(slice.service, None) |
| |
| def test_generic_foreign_key_get(self): |
| service = self.orm.Service(name="myservice") |
| service.save() |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| tag = self.orm.Tag( |
| service=service, |
| name="mytag", |
| value="somevalue", |
| content_type=site.self_content_type_id, |
| object_id=site.id, |
| ) |
| tag.save() |
| self.assertTrue(tag.id > 0) |
| self.assertNotEqual(tag.content_object, None) |
| self.assertEqual(tag.content_object.id, site.id) |
| |
| def test_generic_foreign_key_get_decl(self): |
| service = self.orm.Service(name="myservice") |
| service.save() |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| tag = self.orm.Tag( |
| service=service, |
| name="mytag", |
| value="somevalue", |
| content_type=site.self_content_type_id + "_decl", |
| object_id=site.id, |
| ) |
| tag.save() |
| self.assertTrue(tag.id > 0) |
| self.assertNotEqual(tag.content_object, None) |
| self.assertEqual(tag.content_object.id, site.id) |
| |
| def test_generic_foreign_key_get_bad_contenttype(self): |
| service = self.orm.Service(name="myservice") |
| service.save() |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| tag = self.orm.Tag( |
| service=service, |
| name="mytag", |
| value="somevalue", |
| content_type="does_not_exist", |
| object_id=site.id, |
| ) |
| tag.save() |
| self.assertTrue(tag.id > 0) |
| with self.assertRaises(Exception) as e: |
| |
| self.assertEqual( |
| str(e.exception), |
| "Content_type does_not_exist not found in self.content_type_map", |
| ) |
| |
| def test_generic_foreign_key_get_bad_id(self): |
| service = self.orm.Service(name="myservice") |
| service.save() |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| tag = self.orm.Tag( |
| service=service, |
| name="mytag", |
| value="somevalue", |
| content_type=site.self_content_type_id, |
| object_id=4567, |
| ) |
| tag.save() |
| self.assertTrue(tag.id > 0) |
| with self.assertRaises(Exception) as e: |
| self.assertEqual( |
| str(e.exception), "Object 4567 of model Site was not found" |
| ) |
| |
| def test_generic_foreign_key_set(self): |
| service = self.orm.Service(name="myservice") |
| service.save() |
| site = self.orm.Site(name="mysite") |
| site.save() |
| self.assertTrue(site.id > 0) |
| tag = self.orm.Tag(service=service, name="mytag", value="somevalue") |
| tag.content_object = site |
| tag.invalidate_cache() |
| self.assertEqual(tag.content_type, site.self_content_type_id) |
| self.assertEqual(tag.object_id, site.id) |
| tag.save() |
| self.assertTrue(tag.id > 0) |
| self.assertNotEqual(tag.content_object, None) |
| self.assertEqual(tag.content_object.id, site.id) |
| |
| def test_field_null(self): |
| """ In a saved object, if a nullable field is left set to None, make sure the ORM returns None """ |
| |
| tm = self.orm.TestModel() |
| tm.save() |
| |
| tm = self.orm.TestModel.objects.all()[0] |
| self.assertFalse(tm._wrapped_class.HasField("intfield")) |
| self.assertEqual(tm.intfield, None) |
| |
| def test_field_null_new(self): |
| """ For models that haven't been saved yet, reading the field should return the gRPC default """ |
| |
| tm = self.orm.TestModel() |
| |
| self.assertEqual(tm.intfield, 0) |
| |
| def test_field_non_null(self): |
| """ In a saved object, if a nullable field is set to a value, then make sure the ORM returns the value """ |
| |
| tm = self.orm.TestModel(intfield=3) |
| tm.save() |
| |
| tm = self.orm.TestModel.objects.all()[0] |
| self.assertEqual(tm.intfield, 3) |
| |
| def test_field_set_null(self): |
| """ Setting a field to None is not allowed """ |
| |
| tm = self.orm.TestModel() |
| with self.assertRaises(Exception) as e: |
| tm.intfile = None |
| self.assertEqual( |
| str(e.exception), |
| "Setting a non-foreignkey field to None is not supported", |
| ) |
| |
| def test_deleted_objects_all(self): |
| orig_len_sites = len(self.orm.Site.objects.all()) |
| orig_len_deleted_sites = len(self.orm.Site.deleted_objects.all()) |
| site = self.orm.Site(name="mysite") |
| site.save() |
| site.delete() |
| sites = self.orm.Site.objects.all() |
| self.assertEqual(len(sites), orig_len_sites) |
| deleted_sites = self.orm.Site.deleted_objects.all() |
| self.assertEqual(len(deleted_sites), orig_len_deleted_sites + 1) |
| |
| def test_deleted_objects_filter(self): |
| with patch.object( |
| self.orm.grpc_stub, "FilterTestModel", wraps=self.orm.grpc_stub.FilterTestModel |
| ) as filter: |
| foo = self.orm.TestModel(name="foo") |
| foo.save() |
| foo.delete() |
| |
| # There should be no live objects |
| objs = self.orm.TestModel.objects.filter(name="foo") |
| self.assertEqual(len(objs), 0) |
| |
| # There should be one deleted object |
| deleted_objs = self.orm.TestModel.deleted_objects.filter(name="foo") |
| self.assertEqual(len(deleted_objs), 1) |
| |
| # Two calls, one for when we checked live objects, the other for when we checked deleted objects |
| self.assertEqual(filter.call_count, 2) |
| q = filter.call_args[0][0] |
| |
| # Now spy on the query that was generated, to make sure it looks like we expect |
| self.assertEqual(q.kind, q.SYNCHRONIZER_DELETED_OBJECTS) |
| self.assertEqual(len(q.elements), 1) |
| self.assertEqual(q.elements[0].operator, q.elements[0].EQUAL) |
| self.assertEqual(q.elements[0].sValue, "foo") |
| |
| |
| def main(): |
| global USE_FAKE_STUB |
| global xos_grpc_client |
| |
| # Command-line argument of -R will cause this test to use a real grpc server |
| # rather than the fake stub. |
| |
| if "-R" in sys.argv: |
| USE_FAKE_STUB = False |
| sys.argv.remove("-R") |
| # Note: will leave lots of litter (users, sites, etc) behind in the database |
| |
| if USE_FAKE_STUB: |
| unittest.main() |
| else: |
| # This assumes xos-client python library is installed, and a gRPC server |
| # is available. |
| |
| from xosapi import xos_grpc_client |
| |
| print("Using xos-client library and core server") |
| |
| def test_callback(): |
| try: |
| sys.argv = sys.argv[ |
| :1 |
| ] |
| # unittest does not like xos_grpc_client's command line |
| # arguments (TODO: find a cooperative approach) |
| unittest.main() |
| except SystemExit as e: |
| global exitStatus |
| exitStatus = e.code |
| |
| xos_grpc_client.start_api_parseargs(test_callback) |
| |
| sys.exit(exitStatus) |
| |
| |
| if __name__ == "__main__": |
| main() |