Beispiel #1
0
def test_build_attrs():
    schema = Schema()
    adapter = SAAdapter(SANotIndexable, schema)
    assert not adapter.indexable
    assert adapter.doc_attrs == {}

    adapter = SAAdapter(Entity, schema)
    assert adapter.indexable == False

    adapter = SAAdapter(SubclassEntityIndexable, schema)
    assert adapter.indexable
    assert set(adapter.doc_attrs) == {
        "object_key",
        "id",
        "name",
        "slug",
        "object_type",
        "text",
        "created_at",
        "updated_at",
        "name_prefix",
        "owner",
        "owner_name",
        "creator_name",
        "creator",
        "allowed_roles_and_users",
        "tag_ids",
        "tag_text",
    }
    assert all(lambda f: callable(f) for f in six.itervalues(adapter.doc_attrs))

    assert set(schema.names()) == {
        "object_key",
        "id",
        "object_type",
        "name",
        "slug",
        "text",
        "created_at",
        "updated_at",
        "name_prefix",
        "owner",
        "owner_name",
        "creator_name",
        "creator",
        "allowed_roles_and_users",
        "tag_ids",
        "tag_text",
    }

    schema = Schema(id=NUMERIC(bits=64, signed=False, stored=True, unique=True))
    adapter = SAAdapter(Indexable, schema)
    assert adapter.indexable
    assert set(adapter.doc_attrs) == {"id", "text", "num", "name"}
    assert all(lambda f: callable(f) for f in six.itervalues(adapter.doc_attrs))

    assert set(schema.names()) == {"id", "text", "num", "name"}
    assert isinstance(schema["text"], TEXT)
    assert isinstance(schema["num"], NUMERIC)
def test_build_attrs_4() -> None:
    schema = Schema(
        id=NUMERIC(bits=64, signed=False, stored=True, unique=True))
    adapter = SAAdapter(Indexable, schema)
    assert adapter.indexable
    assert set(adapter.doc_attrs) == {
        "id",
        "text",
        "num",
        "name",
        "object_type",
        "object_key",
    }
    assert all(lambda f: callable(f) for f in adapter.doc_attrs.values())

    assert set(schema.names()) == {
        "id",
        "text",
        "num",
        "name",
        "object_type",
        "object_key",
    }
    assert isinstance(schema["text"], TEXT)
    assert isinstance(schema["num"], NUMERIC)
Beispiel #3
0
def test_get_document_with_schema():
    # test retrieve related attributes
    schema = Schema(id=NUMERIC(bits=64, signed=False, stored=True, unique=True))
    adapter = SAAdapter(Indexable, schema)
    expected = dict(id=1, num=42)
    obj = Indexable(**expected)
    obj.related = type(str("Related"), (object,), dict(name=None))()
    expected["name"] = obj.related.name = "related name"
    obj.related.description = "description text"
    expected["text"] = obj.related.name + " " + obj.related.description
    doc = adapter.get_document(obj)

    assert set(doc) == {"id", "name", "num", "text"}
    assert doc["id"] == 1
    assert doc["num"] == 42
    assert doc["name"] == "related name"
    assert "related name" in doc["text"]
    assert "description text" in doc["text"]
Beispiel #4
0
def test_get_document_with_schema():
    # test retrieve related attributes
    schema = Schema(id=NUMERIC(bits=64, signed=False, stored=True, unique=True))
    adapter = SAAdapter(Indexable, schema)
    expected = {"id": 1, "num": 42}
    obj = Indexable(**expected)
    obj.related = type("Related", (object,), {"name": None})()
    expected["name"] = obj.related.name = "related name"
    obj.related.description = "description text"
    expected["text"] = obj.related.name + " " + obj.related.description
    doc = adapter.get_document(obj)

    assert set(doc) == {"id", "name", "num", "text", "object_type", "object_key"}
    assert doc["id"] == 1
    assert doc["num"] == 42
    assert doc["name"] == "related name"
    assert "related name" in doc["text"]
    assert "description text" in doc["text"]
Beispiel #5
0
    def test_get_document(self):
        schema = Schema()
        adapter = SAAdapter(SubclassEntityIndexable, schema)
        expected = dict(
            id=2,
            name='entity name',
            created_at=datetime(2013, 11, 28, 16, 17, 0),
            updated_at=datetime(2013, 11, 29, 12, 17, 58),
        )
        obj = SubclassEntityIndexable(**expected)
        obj.slug = 'entity-name'

        expected['object_type'] = 'test_adapter.SubclassEntityIndexable'
        expected['object_key'] = 'test_adapter.SubclassEntityIndexable:2'
        expected['text'] = 'entity name'
        expected['slug'] = 'entity-name'
        expected['name_prefix'] = 'entity name'
        expected['allowed_roles_and_users'] = 'role:admin'
        assert adapter.get_document(obj) == expected
def test_get_document(app, db):
    schema = Schema()
    adapter = SAAdapter(SubclassEntityIndexable, schema)
    expected = {
        "id": 2,
        "name": "entity name",
        "created_at": datetime(2013, 11, 28, 16, 17, 0),
        "updated_at": datetime(2013, 11, 29, 12, 17, 58),
    }
    obj = SubclassEntityIndexable(**expected)
    obj.slug = "entity-name"

    expected["object_type"] = "test_adapter.SubclassEntityIndexable"
    expected["object_key"] = "test_adapter.SubclassEntityIndexable:2"
    expected["text"] = "entity name"
    expected["slug"] = "entity-name"
    expected["name_prefix"] = "entity name"
    expected["allowed_roles_and_users"] = "role:admin"

    with app.test_request_context():
        assert adapter.get_document(obj) == expected
Beispiel #7
0
def test_get_document(app, db):
    schema = Schema()
    adapter = SAAdapter(SubclassEntityIndexable, schema)
    expected = {
        "id": 2,
        "name": "entity name",
        "created_at": datetime(2013, 11, 28, 16, 17, 0),
        "updated_at": datetime(2013, 11, 29, 12, 17, 58),
    }
    obj = SubclassEntityIndexable(**expected)
    obj.slug = "entity-name"

    expected["object_type"] = "test_adapter.SubclassEntityIndexable"
    expected["object_key"] = "test_adapter.SubclassEntityIndexable:2"
    expected["text"] = "entity name"
    expected["slug"] = "entity-name"
    expected["name_prefix"] = "entity name"
    expected["allowed_roles_and_users"] = "role:admin"

    with app.test_request_context():
        assert adapter.get_document(obj) == expected
Beispiel #8
0
def test_get_document_with_schema() -> None:
    # test retrieve related attributes
    schema = Schema(
        id=NUMERIC(bits=64, signed=False, stored=True, unique=True))
    adapter = SAAdapter(Indexable, schema)
    expected: Dict[str, Any] = {"id": 1, "num": 42}
    obj = Indexable(**expected)
    obj.related = type("Related", (object, ), {"name": None})()
    expected["name"] = obj.related.name = "related name"
    obj.related.description = "description text"
    expected["text"] = obj.related.name + " " + obj.related.description
    doc = adapter.get_document(obj)

    assert set(doc) == {
        "id", "name", "num", "text", "object_type", "object_key"
    }
    assert doc["id"] == 1
    assert doc["num"] == 42
    assert doc["name"] == "related name"
    assert "related name" in doc["text"]
    assert "description text" in doc["text"]
Beispiel #9
0
  def test_get_document(self):
    schema = Schema()
    adapter = SAAdapter(SubclassEntityIndexable, schema)
    expected = dict(
      id=2,
      name=u'entity name',
      created_at=datetime(2013, 11, 28, 16, 17, 0),
      updated_at=datetime(2013, 11, 29, 12, 17, 58)
    )
    obj = SubclassEntityIndexable(**expected)
    obj.slug = u'entity-name'
    expected['object_type'] = u'test_adapter.SubclassEntityIndexable'
    expected['object_key'] = u'test_adapter.SubclassEntityIndexable:2'
    expected['text'] = u'entity name'
    expected['slug'] = 'entity-name'
    expected['name_prefix'] = u'entity name'
    expected['allowed_roles_and_users'] = u'role:admin'
    assert adapter.get_document(obj) == expected

    # test retrieve related attributes
    schema = Schema(
      id=NUMERIC(numtype=int, bits=64, signed=False, stored=True, unique=True),
    )
    adapter = SAAdapter(Indexable, schema)
    expected = dict(id=1, num=42)
    obj = Indexable(**expected)
    obj.related = type('Related', (object,), dict(name=None))()
    expected['name'] = obj.related.name = u'related name'
    obj.related.description = u'description text'
    expected['text'] = obj.related.name + u' ' + obj.related.description
    doc = adapter.get_document(obj)

    assert set(doc) == {'id', 'name', 'num', 'text'}
    assert doc['id'] == 1
    assert doc['num'] == 42
    assert doc['name'] == u'related name'
    assert u'related name' in doc['text']
    assert u'description text' in doc['text']
Beispiel #10
0
  def test_get_document(self):
    schema = Schema()
    adapter = SAAdapter(SubclassEntityIndexable, schema)
    expected = dict(
      id=2,
      name=u'entity',
      created_at=datetime(2013, 11, 28, 16, 17, 0),
      updated_at=datetime(2013, 11, 29, 12, 17, 58)
    )
    obj = SubclassEntityIndexable(**expected)
    expected['creator_name'] = u''
    expected['owner_name'] = u''
    expected['object_type'] = u'test_adapter.SubclassEntityIndexable'
    expected['object_key'] = u'test_adapter.SubclassEntityIndexable:2'
    expected['text'] = u'entity'
    expected['name_prefix'] = u'entity'
    self.assertEquals(adapter.get_document(obj), expected)

    # test retrieve related attributes
    schema = Schema(
      id=NUMERIC(numtype=int, bits=64, signed=False, stored=True, unique=True),
    )
    adapter = SAAdapter(Indexable, schema)
    expected = dict(id=1, num=42)
    obj = Indexable(**expected)
    obj.related = type('Related', (object,), dict(name=None))()
    expected['name'] = obj.related.name = u'related name'
    obj.related.description = u'description text'
    expected['text'] = obj.related.name + u' ' + obj.related.description
    doc = adapter.get_document(obj)

    self.assertEquals(set(doc), set(('id', 'name', 'num', 'text')))
    self.assertEquals(doc['id'], 1)
    self.assertEquals(doc['num'], 42)
    self.assertEquals(doc['name'], u'related name')
    self.assertTrue(u'related name' in doc['text'])
    self.assertTrue(u'description text' in doc['text'])
Beispiel #11
0
    def test_get_document_with_schema(self):
        # test retrieve related attributes
        schema = Schema(id=NUMERIC(
            numtype=int,
            bits=64,
            signed=False,
            stored=True,
            unique=True,
        ), )
        adapter = SAAdapter(Indexable, schema)
        expected = dict(id=1, num=42)
        obj = Indexable(**expected)
        obj.related = type(str('Related'), (object, ), dict(name=None))()
        expected['name'] = obj.related.name = 'related name'
        obj.related.description = 'description text'
        expected['text'] = obj.related.name + ' ' + obj.related.description
        doc = adapter.get_document(obj)

        assert set(doc) == {'id', 'name', 'num', 'text'}
        assert doc['id'] == 1
        assert doc['num'] == 42
        assert doc['name'] == 'related name'
        assert 'related name' in doc['text']
        assert 'description text' in doc['text']
def test_build_attrs_3() -> None:
    schema = Schema()
    adapter = SAAdapter(SubclassEntityIndexable, schema)
    assert adapter.indexable
    assert set(adapter.doc_attrs) == {
        "allowed_roles_and_users",
        "created_at",
        "creator",
        "creator_name",
        "id",
        "name",
        "name_prefix",
        "object_key",
        "object_type",
        "owner",
        "owner_name",
        "slug",
        "tag_ids",
        "tag_text",
        "text",
        "updated_at",
    }
    assert all(lambda f: callable(f) for f in adapter.doc_attrs.values())

    assert set(schema.names()) == {
        "allowed_roles_and_users",
        "created_at",
        "creator",
        "creator_name",
        "id",
        "name",
        "name_prefix",
        "object_key",
        "object_type",
        "owner",
        "owner_name",
        "slug",
        "tag_ids",
        "tag_text",
        "text",
        "updated_at",
    }
Beispiel #13
0
    def test_get_document(self):
        schema = Schema()
        adapter = SAAdapter(SubclassEntityIndexable, schema)
        expected = dict(id=2,
                        name='entity name',
                        created_at=datetime(2013, 11, 28, 16, 17, 0),
                        updated_at=datetime(2013, 11, 29, 12, 17, 58))
        obj = SubclassEntityIndexable(**expected)
        obj.slug = u'entity-name'
        expected['object_type'] = u'test_adapter.SubclassEntityIndexable'
        expected['object_key'] = u'test_adapter.SubclassEntityIndexable:2'
        expected['text'] = u'entity name'
        expected['slug'] = 'entity-name'
        expected['name_prefix'] = u'entity name'
        expected['allowed_roles_and_users'] = u'role:admin'
        assert adapter.get_document(obj) == expected

        # test retrieve related attributes
        schema = Schema(id=NUMERIC(numtype=int,
                                   bits=64,
                                   signed=False,
                                   stored=True,
                                   unique=True), )
        adapter = SAAdapter(Indexable, schema)
        expected = dict(id=1, num=42)
        obj = Indexable(**expected)
        obj.related = type(str('Related'), (object, ), dict(name=None))()
        expected['name'] = obj.related.name = u'related name'
        obj.related.description = u'description text'
        expected['text'] = obj.related.name + u' ' + obj.related.description
        doc = adapter.get_document(obj)

        assert set(doc) == {'id', 'name', 'num', 'text'}
        assert doc['id'] == 1
        assert doc['num'] == 42
        assert doc['name'] == u'related name'
        assert u'related name' in doc['text']
        assert u'description text' in doc['text']
def test_build_attrs_2() -> None:
    schema = Schema()
    adapter = SAAdapter(Entity, schema)
    assert adapter.indexable == False
def test_build_attrs_1() -> None:
    schema = Schema()
    adapter = SAAdapter(SANotIndexable, schema)
    assert not adapter.indexable
    assert adapter.doc_attrs == {}
Beispiel #16
0
 def test_can_adapt(self):
     assert not SAAdapter.can_adapt(SANotAdaptable)
     assert SAAdapter.can_adapt(SANotIndexable)
     assert SAAdapter.can_adapt(Indexable)
     assert SAAdapter.can_adapt(Entity)
Beispiel #17
0
 def test_can_adapt(self):
   self.assertFalse(SAAdapter.can_adapt(SANotAdaptable))
   self.assertTrue(SAAdapter.can_adapt(SANotIndexable))
   self.assertTrue(SAAdapter.can_adapt(Indexable))
   self.assertTrue(SAAdapter.can_adapt(Entity))
Beispiel #18
0
    def test_build_attrs(self):
        schema = Schema()
        adapter = SAAdapter(SANotIndexable, schema)
        assert not adapter.indexable
        assert adapter.doc_attrs == {}

        adapter = SAAdapter(Entity, schema)
        assert adapter.indexable == False

        adapter = SAAdapter(SubclassEntityIndexable, schema)
        assert adapter.indexable
        assert set(adapter.doc_attrs) == {
            'object_key',
            'id',
            'name',
            'slug',
            'object_type',
            'text',
            'created_at',
            'updated_at',
            'name_prefix',
            'owner',
            'owner_name',
            'creator_name',
            'creator',
            'allowed_roles_and_users',
            'tag_ids',
            'tag_text',
        }
        assert all(lambda f: callable(f)
                   for f in six.itervalues(adapter.doc_attrs))

        assert set(schema.names()) == {
            'object_key',
            'id',
            'object_type',
            'name',
            'slug',
            'text',
            'created_at',
            'updated_at',
            'name_prefix',
            'owner',
            'owner_name',
            'creator_name',
            'creator',
            'allowed_roles_and_users',
            'tag_ids',
            'tag_text',
        }

        schema = Schema(id=NUMERIC(numtype=int,
                                   bits=64,
                                   signed=False,
                                   stored=True,
                                   unique=True), )
        adapter = SAAdapter(Indexable, schema)
        assert adapter.indexable
        assert set(adapter.doc_attrs) == {'id', 'text', 'num', 'name'}
        assert all(lambda f: callable(f)
                   for f in six.itervalues(adapter.doc_attrs))

        assert set(schema.names()) == {'id', 'text', 'num', 'name'}
        assert isinstance(schema['text'], TEXT)
        assert isinstance(schema['num'], NUMERIC)
Beispiel #19
0
 def test_can_adapt(self):
   assert not SAAdapter.can_adapt(SANotAdaptable)
   assert SAAdapter.can_adapt(SANotIndexable)
   assert SAAdapter.can_adapt(Indexable)
   assert SAAdapter.can_adapt(Entity)