def helper_test(test_class, test_class_call):
mock_rest = mock_connection_method('post')
schema = Schema(mock_rest)
schema._create_class_with_premitives(test_class)
self.assertEqual(mock_rest.post.call_count, 1)
mock_rest.post.assert_called_with(
path="/schema",
weaviate_object=test_class_call,
)
def test__create_classes_with_primitives(self):
"""
Test the `_create_classes_with_primitives` method.
"""
schema = Schema(Mock())
mock_primitive = Mock()
schema._create_class_with_premitives = mock_primitive
schema._create_classes_with_primitives(list("Test!!"))
self.assertEqual(mock_primitive.call_count, 6)
def test__create_complex_properties_from_classes(self):
"""
Test the `_create_complex_properties_from_classes` method.
"""
schema = Schema(Mock())
mock_complex = Mock()
schema._create_complex_properties_from_class = mock_complex
schema._create_complex_properties_from_classes(list("Test!"))
self.assertEqual(mock_complex.call_count, 5)
def helper_test(nr_calls=1):
mock_rest = mock_connection_method('post')
schema = Schema(mock_rest)
schema._create_complex_properties_from_class(properties)
self.assertEqual(mock_rest.post.call_count, nr_calls)
properties_copy = deepcopy(properties['properties'])
for prop in properties_copy:
prop['dataType'] = [
_capitalize_first_letter(dt) for dt in prop['dataType']
]
mock_rest.post.assert_called_with(
path="/schema/" +
_capitalize_first_letter(properties["class"]) + "/properties",
weaviate_object=properties_copy[0])
def test_delete_everything(self):
"""
Test the `delete_all` method.
"""
mock_connection = mock_connection_method(
'get', return_json=company_test_schema)
mock_connection = mock_connection_method(
'delete', connection_mock=mock_connection)
schema = Schema(mock_connection)
schema.delete_all()
self.assertEqual(mock_connection.get.call_count, 1)
self.assertEqual(mock_connection.delete.call_count, 2)
def test_create_class(self):
"""
Test the `create_class` method.
"""
schema = Schema(Mock())
# mock function calls
mock_primitive = Mock()
mock_complex = Mock()
schema._create_class_with_premitives = mock_primitive
schema._create_complex_properties_from_class = mock_complex
schema.create_class(company_test_schema["classes"][0])
mock_primitive.assert_called_with(company_test_schema["classes"][0])
mock_complex.assert_called_with(company_test_schema["classes"][0])
def test_create(self):
"""
Test the `create` method.
"""
schema = Schema(Mock())
# mock function calls
mock_primitive = Mock()
mock_complex = Mock()
schema._create_classes_with_primitives = mock_primitive
schema._create_complex_properties_from_classes = mock_complex
schema.create("test/schema/schema_company.json") # with read from file
mock_primitive.assert_called_with(schema_company_local["classes"])
mock_complex.assert_called_with(schema_company_local["classes"])
def test__create_class_with_premitives(self):
"""
Test the `_create_class_with_premitives` method.
"""
# valid calls
def helper_test(test_class, test_class_call):
mock_rest = mock_connection_method('post')
schema = Schema(mock_rest)
schema._create_class_with_premitives(test_class)
self.assertEqual(mock_rest.post.call_count, 1)
mock_rest.post.assert_called_with(
path="/schema",
weaviate_object=test_class_call,
)
test_class = {
"class":
"TestClass",
"properties": [{
'dataType': ['int'],
'name': 'test_prop',
'description': 'None'
}, {
'dataType': ['Test'],
'name': 'test_prop',
'description': 'None'
}]
}
test_class_call = {
"class":
"TestClass",
"properties": [
{
'dataType': ['int'],
'name': 'test_prop',
'description': 'None'
},
]
}
helper_test(test_class, test_class_call)
test_class['description'] = 'description'
test_class_call['description'] = 'description'
helper_test(test_class, test_class_call)
test_class['description'] = 'description'
test_class_call['description'] = 'description'
helper_test(test_class, test_class_call)
test_class['vectorIndexType'] = 'vectorIndexType'
test_class_call['vectorIndexType'] = 'vectorIndexType'
helper_test(test_class, test_class_call)
test_class['vectorIndexConfig'] = {
'vectorIndexConfig': 'vectorIndexConfig'
}
test_class_call['vectorIndexConfig'] = {
'vectorIndexConfig': 'vectorIndexConfig'
}
helper_test(test_class, test_class_call)
test_class['vectorizer'] = 'test_vectorizer'
test_class_call['vectorizer'] = 'test_vectorizer'
helper_test(test_class, test_class_call)
test_class['moduleConfig'] = {'moduleConfig': 'moduleConfig'}
test_class_call['moduleConfig'] = {'moduleConfig': 'moduleConfig'}
helper_test(test_class, test_class_call)
test_class['shardingConfig'] = {'shardingConfig': 'shardingConfig'}
test_class_call['shardingConfig'] = {
'shardingConfig': 'shardingConfig'
}
helper_test(test_class, test_class_call)
# multiple properties do not imply multiple `run_rest` calls
test_class['properties'].append(
test_class['properties'][0]) # add another property
test_class['properties'].append(
test_class['properties'][0]) # add another property
test_class_call['properties'].append(
test_class['properties'][0]) # add another property
test_class_call['properties'].append(
test_class['properties'][0]) # add another property
helper_test(test_class, test_class_call)
# with uncapitalized class_name
test_class['class'] = 'testClass'
helper_test(test_class, test_class_call)
# invalid calls
requests_error_message = 'Class may not have been created properly.'
mock_rest = mock_connection_method(
'post', side_effect=RequestsConnectionError('TEST1'))
schema = Schema(mock_rest)
with self.assertRaises(RequestsConnectionError) as error:
schema._create_class_with_premitives(test_class)
check_error_message(self, error, requests_error_message)
mock_rest = mock_connection_method('post', status_code=404)
schema = Schema(mock_rest)
with self.assertRaises(UnexpectedStatusCodeException) as error:
schema._create_class_with_premitives(test_class)
check_startswith_error_message(self, error, "Create class")
def test__create_complex_properties_from_class(self):
"""
Test the `_create_complex_properties_from_class` method.
"""
# valid calls
def helper_test(nr_calls=1):
mock_rest = mock_connection_method('post')
schema = Schema(mock_rest)
schema._create_complex_properties_from_class(properties)
self.assertEqual(mock_rest.post.call_count, nr_calls)
properties_copy = deepcopy(properties['properties'])
for prop in properties_copy:
prop['dataType'] = [
_capitalize_first_letter(dt) for dt in prop['dataType']
]
mock_rest.post.assert_called_with(
path="/schema/" +
_capitalize_first_letter(properties["class"]) + "/properties",
weaviate_object=properties_copy[0])
# no `properties` key
mock_rest = mock_connection_method('post')
schema = Schema(mock_rest)
schema._create_complex_properties_from_class({})
self.assertEqual(mock_rest.run_rest.call_count, 0)
# no COMPLEX properties
properties = {'properties': [{'dataType': ["text"]}]}
schema._create_complex_properties_from_class(properties)
self.assertEqual(mock_rest.post.call_count, 0)
properties = {
'properties': [{
'dataType': ["text"]
}, {
'dataType': ['string']
}]
}
schema._create_complex_properties_from_class(properties)
self.assertEqual(mock_rest.post.call_count, 0)
# COMPLEX properties
properties = {
'class':
'TestClass',
'properties': [
{
'dataType': ["Test"],
'description': "test description",
'name': 'test_prop'
},
]
}
mock_rest = mock_connection_method('post')
schema = Schema(mock_rest)
schema._create_complex_properties_from_class(properties)
self.assertEqual(mock_rest.post.call_count, 1)
properties = {
'class':
'TestClass',
'properties': [
{
'dataType': ["Test"],
'description': "test description",
'name': 'test_prop'
},
]
}
helper_test()
properties['properties'][0]['indexInverted'] = True
helper_test()
properties['properties'][0]['moduleConfig'] = {'test': 'ok!'}
helper_test()
properties['properties'].append(
properties['properties'][0]) # add another property
properties['properties'].append(
properties['properties'][0]) # add another property
helper_test(3)
# with uncapitalized class_name
properties['class'] = 'testClass'
helper_test(3)
properties = {
'class':
'testClass',
'properties': [
{
'dataType': ["test", 'myTest'],
'description': "test description",
'name': 'test_prop'
},
]
}
# invalid calls
requests_error_message = 'Property may not have been created properly.'
mock_rest = mock_connection_method(
'post', side_effect=RequestsConnectionError('TEST1'))
schema = Schema(mock_rest)
with self.assertRaises(RequestsConnectionError) as error:
schema._create_complex_properties_from_class(properties)
check_error_message(self, error, requests_error_message)
mock_rest = mock_connection_method('post', status_code=404)
schema = Schema(mock_rest)
with self.assertRaises(UnexpectedStatusCodeException) as error:
schema._create_complex_properties_from_class(properties)
check_startswith_error_message(self, error,
"Add properties to classes")
def test_delete_class_input(self):
"""
Test the 'delete_class` method.
"""
schema = Schema(Mock())
# invalid calls
type_error_message = lambda t: f"Class name was {t} instead of str"
requests_error_message = 'Deletion of class.'
with self.assertRaises(TypeError) as error:
schema.delete_class(1)
check_error_message(self, error, type_error_message(int))
schema = Schema(
mock_connection_method(
'delete', side_effect=RequestsConnectionError('Test!')))
with self.assertRaises(RequestsConnectionError) as error:
schema.delete_class("uuid")
check_error_message(self, error, requests_error_message)
schema = Schema(mock_connection_method('delete', status_code=404))
with self.assertRaises(UnexpectedStatusCodeException) as error:
schema.delete_class("uuid")
check_startswith_error_message(self, error, "Delete class from schema")
# valid calls
mock_conn = mock_connection_method('delete', status_code=200)
schema = Schema(mock_conn)
schema.delete_class("Test")
mock_conn.delete.assert_called_with(path="/schema/Test")
# with uncapitalized class_name
mock_conn = mock_connection_method('delete', status_code=200)
schema = Schema(mock_conn)
schema.delete_class("test")
mock_conn.delete.assert_called_with(path="/schema/Test")
def test_contains(self):
"""
Test the `contains` method.
"""
# If a schema is present it should return true otherwise false
# 1. test schema is present:
schema = Schema(
mock_connection_method('get',
return_json=persons_return_test_schema))
self.assertTrue(schema.contains())
# 2. test no schema is present:
schema = Schema(
mock_connection_method('get', return_json={"classes": []}))
self.assertFalse(schema.contains())
# 3. test with 'schema' argument
## Test weaviate.schema.contains specific schema.
schema = Schema(
mock_connection_method('get',
return_json=persons_return_test_schema))
self.assertFalse(schema.contains(company_test_schema))
subset_schema = {
"classes": [{
"class":
"Person",
"description":
"",
"properties": [{
"dataType": ["text"],
"description": "",
"name": "name"
}]
}]
}
self.assertTrue(schema.contains(subset_schema))
## Test weaviate.schema.contains schema from file.
schema = Schema(
mock_connection_method('get',
return_json=persons_return_test_schema))
schema_json_file = os.path.join(os.path.dirname(__file__),
"schema_company.json")
self.assertFalse(schema.contains(schema_json_file))
schema = Schema(
mock_connection_method('get', return_json=company_test_schema))
self.assertTrue(schema.contains(schema_json_file))
def test_get(self):
"""
Test the `get` method.
"""
# invalid calls
requests_error_message = 'Schema could not be retrieved.'
unexpected_error_msg = "Get schema"
type_error_msg = lambda dt: f"'class_name' argument must be of type `str`! Given type: {dt}"
mock_conn = mock_connection_method(
'get', side_effect=RequestsConnectionError("Test!"))
schema = Schema(mock_conn)
with self.assertRaises(RequestsConnectionError) as error:
schema.get()
check_error_message(self, error, requests_error_message)
mock_conn = mock_connection_method('get', status_code=404)
schema = Schema(mock_conn)
with self.assertRaises(UnexpectedStatusCodeException) as error:
schema.get()
check_startswith_error_message(self, error, unexpected_error_msg)
connection_mock_file = mock_connection_method(
'get', status_code=200, return_json={'Test': 'OK!'})
schema = Schema(connection_mock_file)
with self.assertRaises(TypeError) as error:
schema.get(1234)
check_error_message(self, error, type_error_msg(int))
# valid calls
self.assertEqual(schema.get(), {'Test': 'OK!'})
connection_mock_file.get.assert_called_with(path="/schema", )
self.assertEqual(schema.get("Artist"), {'Test': 'OK!'})
connection_mock_file.get.assert_called_with(path="/schema/Artist")
# with uncapitalized class_name
self.assertEqual(schema.get("artist"), {'Test': 'OK!'})
connection_mock_file.get.assert_called_with(path="/schema/Artist")
def test_update_config(self, mock_schema):
"""
Test the `update_config` method.
"""
# invalid calls
requests_error_message = 'Class schema configuration could not be updated.'
unexpected_error_msg = 'Update class schema configuration'
mock_schema.return_value = {
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 2
}
}
mock_conn = mock_connection_method(
'put', side_effect=RequestsConnectionError("Test!"))
schema = Schema(mock_conn)
with self.assertRaises(RequestsConnectionError) as error:
schema.update_config("Test",
{'vectorIndexConfig': {
'test2': 'Test2'
}})
check_error_message(self, error, requests_error_message)
mock_conn.put.assert_called_with(path="/schema/Test",
weaviate_object={
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 'Test2'
}
})
mock_schema.return_value = {
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 2
}
}
mock_conn = mock_connection_method('put', status_code=404)
schema = Schema(mock_conn)
with self.assertRaises(UnexpectedStatusCodeException) as error:
schema.update_config("Test",
{'vectorIndexConfig': {
'test3': True
}})
check_startswith_error_message(self, error, unexpected_error_msg)
mock_conn.put.assert_called_with(path="/schema/Test",
weaviate_object={
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 2,
'test3': True
}
})
# valid calls
mock_schema.return_value = {
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 2
}
}
mock_conn = mock_connection_method('put')
schema = Schema(mock_conn)
schema.update_config("Test", {})
mock_conn.put.assert_called_with(path="/schema/Test",
weaviate_object={
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 2
}
})
# with uncapitalized class_name
mock_schema.return_value = {
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 2
}
}
mock_conn = mock_connection_method('put')
schema = Schema(mock_conn)
schema.update_config("test", {})
mock_conn.put.assert_called_with(path="/schema/Test",
weaviate_object={
'class': 'Test',
'vectorIndexConfig': {
'test1': 'Test1',
'test2': 2
}
})