def test_update_row(data_fixture):
user = data_fixture.create_user()
user_2 = data_fixture.create_user()
table = data_fixture.create_database_table(name='Car', user=user)
name_field = data_fixture.create_text_field(table=table,
name='Name',
text_default='Test')
speed_field = data_fixture.create_number_field(table=table,
name='Max speed',
number_negative=True)
price_field = data_fixture.create_number_field(table=table,
name='Price',
number_type='DECIMAL',
number_decimal_places=2,
number_negative=False)
handler = RowHandler()
row = handler.create_row(user=user, table=table)
with pytest.raises(UserNotInGroupError):
handler.update_row(user=user_2, table=table, row_id=row.id, values={})
with pytest.raises(RowDoesNotExist):
handler.update_row(user=user, table=table, row_id=99999, values={})
with pytest.raises(ValidationError):
handler.update_row(user=user,
table=table,
row_id=row.id,
values={price_field.id: -10.99})
handler.update_row(user=user,
table=table,
row_id=row.id,
values={
name_field.id: 'Tesla',
speed_field.id: 240,
f'field_{price_field.id}': 59999.99
})
row.refresh_from_db()
assert getattr(row, f'field_{name_field.id}') == 'Tesla'
assert getattr(row, f'field_{speed_field.id}') == 240
assert getattr(row, f'field_{price_field.id}') == Decimal('59999.99')
def test_link_row_field_type_rows(data_fixture):
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user, name="Placeholder")
example_table = data_fixture.create_database_table(
name="Example", database=database
)
customers_table = data_fixture.create_database_table(
name="Customers", database=database
)
data_fixture.create_text_field(name="Name", table=customers_table, primary=True)
users_table = data_fixture.create_database_table(name="Users", database=database)
field_handler = FieldHandler()
row_handler = RowHandler()
link_row_field = field_handler.create_field(
user=user,
table=example_table,
type_name="link_row",
link_row_table=customers_table,
)
customers_row_1 = row_handler.create_row(user=user, table=customers_table)
customers_row_2 = row_handler.create_row(user=user, table=customers_table)
customers_row_3 = row_handler.create_row(user=user, table=customers_table)
row = row_handler.create_row(
user=user,
table=example_table,
values={
f"field_{link_row_field.id}": [customers_row_1.id, customers_row_2.id],
},
)
row_2 = row_handler.create_row(
user=user,
table=example_table,
values={
f"field_{link_row_field.id}": [customers_row_1.id],
},
)
example_table.name = "Example2"
example_table.save()
customers_table.name = "Customers2"
customers_table.save()
row_1_all = getattr(row, f"field_{link_row_field.id}").all()
row_2_all = getattr(row_2, f"field_{link_row_field.id}").all()
row_1_ids = [i.id for i in row_1_all]
row_2_ids = [i.id for i in row_2_all]
assert row_1_all.count() == 2
assert row_2_all.count() == 1
assert customers_row_1.id in row_1_ids
assert customers_row_2.id in row_1_ids
assert customers_row_1.id in row_2_ids
row = row_handler.update_row(
user=user,
table=example_table,
row_id=row.id,
values={f"field_{link_row_field.id}": [customers_row_3.id]},
)
row_2 = row_handler.update_row(
user=user,
table=example_table,
row_id=row_2.id,
values={f"field_{link_row_field.id}": [customers_row_2.id, customers_row_1.id]},
)
row_1_all = getattr(row, f"field_{link_row_field.id}").all()
row_2_all = getattr(row_2, f"field_{link_row_field.id}").all()
row_1_ids = [i.id for i in row_1_all]
row_2_ids = [i.id for i in row_2_all]
assert row_1_all.count() == 1
assert row_2_all.count() == 2
assert customers_row_3.id in row_1_ids
assert customers_row_1.id in row_2_ids
assert customers_row_2.id in row_2_ids
# Check if the relations are there via the customers table.
customers_table.refresh_from_db()
customers_model = customers_table.get_model()
related_field = link_row_field.link_row_related_field
customer_rows = customers_model.objects.all()
assert customer_rows.count() == 3
customers_row_1 = customer_rows[0]
customers_row_2 = customer_rows[1]
customers_row_3 = customer_rows[2]
customer_row_1_all = getattr(customers_row_1, f"field_{related_field.id}").all()
customer_row_2_all = getattr(customers_row_2, f"field_{related_field.id}").all()
customer_row_3_all = getattr(customers_row_3, f"field_{related_field.id}").all()
assert customer_row_1_all.count() == 1
assert customer_row_2_all.count() == 1
assert customer_row_3_all.count() == 1
customers_row_1_ids = [i.id for i in customer_row_1_all]
customers_row_2_ids = [i.id for i in customer_row_2_all]
customers_row_3_ids = [i.id for i in customer_row_3_all]
assert row_2.id in customers_row_1_ids
assert row_2.id in customers_row_2_ids
assert row.id in customers_row_3_ids
# When changing the link row table table all the existing relations should be
# deleted.
link_row_field = field_handler.update_field(
user=user,
field=link_row_field,
type_name="link_row",
link_row_table=users_table,
)
example_table.refresh_from_db()
model = example_table.get_model()
rows = model.objects.all()
row = rows[0]
row_2 = rows[1]
assert getattr(row, f"field_{link_row_field.id}").all().count() == 0
assert getattr(row_2, f"field_{link_row_field.id}").all().count() == 0
# Just check if the field can be deleted can be deleted.
field_handler.delete_field(user=user, field=link_row_field)
# We expect only the primary field to be left.
assert Field.objects.all().count() == 1
def test_link_row_field_type_rows(data_fixture):
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user,
name='Placeholder')
example_table = data_fixture.create_database_table(name='Example',
database=database)
customers_table = data_fixture.create_database_table(name='Customers',
database=database)
users_table = data_fixture.create_database_table(name='Users',
database=database)
field_handler = FieldHandler()
row_handler = RowHandler()
link_row_field = field_handler.create_field(user=user,
table=example_table,
type_name='link_row',
link_row_table=customers_table)
customers_row_1 = row_handler.create_row(user=user, table=customers_table)
customers_row_2 = row_handler.create_row(user=user, table=customers_table)
customers_row_3 = row_handler.create_row(user=user, table=customers_table)
row = row_handler.create_row(user=user,
table=example_table,
values={
f'field_{link_row_field.id}':
[customers_row_1.id, customers_row_2.id],
})
row_2 = row_handler.create_row(user=user,
table=example_table,
values={
f'field_{link_row_field.id}':
[customers_row_1.id],
})
example_table.name = 'Example2'
example_table.save()
customers_table.name = 'Customers2'
customers_table.save()
row_1_all = getattr(row, f'field_{link_row_field.id}').all()
row_2_all = getattr(row_2, f'field_{link_row_field.id}').all()
row_1_ids = [i.id for i in row_1_all]
row_2_ids = [i.id for i in row_2_all]
assert row_1_all.count() == 2
assert row_2_all.count() == 1
assert customers_row_1.id in row_1_ids
assert customers_row_2.id in row_1_ids
assert customers_row_1.id in row_2_ids
row = row_handler.update_row(
user=user,
table=example_table,
row_id=row.id,
values={f'field_{link_row_field.id}': [customers_row_3.id]})
row_2 = row_handler.update_row(
user=user,
table=example_table,
row_id=row_2.id,
values={
f'field_{link_row_field.id}':
[customers_row_2.id, customers_row_1.id]
})
row_1_all = getattr(row, f'field_{link_row_field.id}').all()
row_2_all = getattr(row_2, f'field_{link_row_field.id}').all()
row_1_ids = [i.id for i in row_1_all]
row_2_ids = [i.id for i in row_2_all]
assert row_1_all.count() == 1
assert row_2_all.count() == 2
assert customers_row_3.id in row_1_ids
assert customers_row_1.id in row_2_ids
assert customers_row_2.id in row_2_ids
# Check if the relations are there via the customers table.
customers_table.refresh_from_db()
customers_model = customers_table.get_model()
related_field = link_row_field.link_row_related_field
customer_rows = customers_model.objects.all()
assert customer_rows.count() == 3
customers_row_1 = customer_rows[0]
customers_row_2 = customer_rows[1]
customers_row_3 = customer_rows[2]
customer_row_1_all = getattr(customers_row_1,
f'field_{related_field.id}').all()
customer_row_2_all = getattr(customers_row_2,
f'field_{related_field.id}').all()
customer_row_3_all = getattr(customers_row_3,
f'field_{related_field.id}').all()
assert customer_row_1_all.count() == 1
assert customer_row_2_all.count() == 1
assert customer_row_3_all.count() == 1
customers_row_1_ids = [i.id for i in customer_row_1_all]
customers_row_2_ids = [i.id for i in customer_row_2_all]
customers_row_3_ids = [i.id for i in customer_row_3_all]
assert row_2.id in customers_row_1_ids
assert row_2.id in customers_row_2_ids
assert row.id in customers_row_3_ids
# When changing the link row table table all the existing relations should be
# deleted.
link_row_field = field_handler.update_field(user=user,
field=link_row_field,
type_name='link_row',
link_row_table=users_table)
example_table.refresh_from_db()
model = example_table.get_model()
rows = model.objects.all()
row = rows[0]
row_2 = rows[1]
assert getattr(row, f'field_{link_row_field.id}').all().count() == 0
assert getattr(row_2, f'field_{link_row_field.id}').all().count() == 0
# Just check if the field can be deleted can be deleted.
field_handler.delete_field(user=user, field=link_row_field)
assert Field.objects.all().count() == 0
def test_single_select_field_type_rows(data_fixture,
django_assert_num_queries):
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user,
name='Placeholder')
table = data_fixture.create_database_table(name='Example',
database=database)
other_select_option = data_fixture.create_select_option()
field_handler = FieldHandler()
row_handler = RowHandler()
field = field_handler.create_field(user=user,
table=table,
type_name='single_select',
select_options=[{
'value': 'Option 1',
'color': 'red'
}, {
'value': 'Option 2',
'color': 'blue'
}])
with pytest.raises(ValidationError):
row_handler.create_row(user=user,
table=table,
values={f'field_{field.id}': 999999})
with pytest.raises(ValidationError):
row_handler.create_row(
user=user,
table=table,
values={f'field_{field.id}': other_select_option.id})
select_options = field.select_options.all()
row = row_handler.create_row(
user=user,
table=table,
values={f'field_{field.id}': select_options[0].id})
assert getattr(row, f'field_{field.id}').id == select_options[0].id
assert getattr(row, f'field_{field.id}').value == select_options[0].value
assert getattr(row, f'field_{field.id}').color == select_options[0].color
assert getattr(row, f'field_{field.id}_id') == select_options[0].id
field = field_handler.update_field(user=user,
field=field,
select_options=[
{
'value': 'Option 3',
'color': 'orange'
},
{
'value': 'Option 4',
'color': 'purple'
},
])
select_options = field.select_options.all()
row_2 = row_handler.create_row(
user=user,
table=table,
values={f'field_{field.id}': select_options[0].id})
assert getattr(row_2, f'field_{field.id}').id == select_options[0].id
assert getattr(row_2, f'field_{field.id}').value == select_options[0].value
assert getattr(row_2, f'field_{field.id}').color == select_options[0].color
assert getattr(row_2, f'field_{field.id}_id') == select_options[0].id
row_3 = row_handler.create_row(
user=user,
table=table,
values={f'field_{field.id}': select_options[1].id})
assert getattr(row_3, f'field_{field.id}').id == select_options[1].id
assert getattr(row_3, f'field_{field.id}_id') == select_options[1].id
row_4 = row_handler.create_row(
user=user,
table=table,
values={f'field_{field.id}': select_options[0].id})
assert getattr(row_4, f'field_{field.id}').id == select_options[0].id
assert getattr(row_4, f'field_{field.id}_id') == select_options[0].id
model = table.get_model()
with django_assert_num_queries(2):
rows = list(model.objects.all().enhance_by_fields())
assert getattr(rows[0], f'field_{field.id}') is None
assert getattr(rows[1], f'field_{field.id}').id == select_options[0].id
assert getattr(rows[2], f'field_{field.id}').id == select_options[1].id
assert getattr(rows[3], f'field_{field.id}').id == select_options[0].id
row.refresh_from_db()
assert getattr(row, f'field_{field.id}') is None
assert getattr(row, f'field_{field.id}_id') is None
field = field_handler.update_field(user=user,
field=field,
new_type_name='text')
assert field.select_options.all().count() == 0
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
assert getattr(rows[0], f'field_{field.id}') is None
assert getattr(rows[1], f'field_{field.id}') == 'Option 3'
assert getattr(rows[2], f'field_{field.id}') == 'Option 4'
assert getattr(rows[3], f'field_{field.id}') == 'Option 3'
field = field_handler.update_field(user=user,
field=field,
new_type_name='single_select',
select_options=[
{
'value': 'Option 2',
'color': 'blue'
},
{
'value': 'option 3',
'color': 'purple'
},
])
assert field.select_options.all().count() == 2
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
select_options = field.select_options.all()
assert getattr(rows[0], f'field_{field.id}') is None
assert getattr(rows[1], f'field_{field.id}').id == select_options[1].id
assert getattr(rows[2], f'field_{field.id}') is None
assert getattr(rows[3], f'field_{field.id}').id == select_options[1].id
row_4 = row_handler.update_row(user=user,
table=table,
row_id=row_4.id,
values={f'field_{field.id}': None})
assert getattr(row_4, f'field_{field.id}') is None
assert getattr(row_4, f'field_{field.id}_id') is None
field = field_handler.update_field(user=user,
field=field,
new_type_name='text')
assert field.select_options.all().count() == 0
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
assert getattr(rows[0], f'field_{field.id}') is None
assert getattr(rows[1], f'field_{field.id}') == 'option 3'
assert getattr(rows[2], f'field_{field.id}') is None
assert getattr(rows[3], f'field_{field.id}') is None
field = field_handler.update_field(user=user,
field=field,
new_type_name='single_select')
assert field.select_options.all().count() == 0
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
assert getattr(rows[0], f'field_{field.id}') is None
assert getattr(rows[1], f'field_{field.id}') is None
assert getattr(rows[2], f'field_{field.id}') is None
assert getattr(rows[3], f'field_{field.id}') is None
def test_file_field_type(data_fixture):
user = data_fixture.create_user()
table = data_fixture.create_database_table(user=user)
user_file_1 = data_fixture.create_user_file()
user_file_2 = data_fixture.create_user_file()
user_file_3 = data_fixture.create_user_file()
field_handler = FieldHandler()
row_handler = RowHandler()
file = field_handler.create_field(user=user, table=table, type_name='file',
name='File')
assert FileField.objects.all().count() == 1
model = table.get_model(attribute_names=True)
with pytest.raises(ValidationError):
row_handler.create_row(user=user, table=table, values={
'file': 'not_a_json'
}, model=model)
with pytest.raises(ValidationError):
row_handler.create_row(user=user, table=table, values={
'file': {}
}, model=model)
with pytest.raises(ValidationError):
row_handler.create_row(user=user, table=table, values={
'file': [{'no_name': 'test'}]
}, model=model)
with pytest.raises(InvalidUserFileNameError):
row_handler.create_row(user=user, table=table, values={
'file': [{'name': 'wrongfilename.jpg'}]
}, model=model)
with pytest.raises(UserFileDoesNotExist):
row_handler.create_row(user=user, table=table, values={
'file': [{'name': 'file_name.jpg'}]
}, model=model)
row = row_handler.create_row(user=user, table=table, values={
'file': [{'name': user_file_1.name}]
}, model=model)
assert row.file[0]['visible_name'] == user_file_1.original_name
del row.file[0]['visible_name']
assert row.file[0] == user_file_1.serialize()
row = row_handler.create_row(user=user, table=table, values={
'file': [
{'name': user_file_2.name},
{'name': user_file_1.name},
{'name': user_file_1.name}
]
}, model=model)
assert row.file[0]['visible_name'] == user_file_2.original_name
assert row.file[1]['visible_name'] == user_file_1.original_name
assert row.file[2]['visible_name'] == user_file_1.original_name
del row.file[0]['visible_name']
del row.file[1]['visible_name']
del row.file[2]['visible_name']
assert row.file[0] == user_file_2.serialize()
assert row.file[1] == user_file_1.serialize()
assert row.file[2] == user_file_1.serialize()
row = row_handler.create_row(user=user, table=table, values={
'file': [
{'name': user_file_1.name},
{'name': user_file_3.name},
{'name': user_file_2.name}
]
}, model=model)
assert row.file[0]['visible_name'] == user_file_1.original_name
assert row.file[1]['visible_name'] == user_file_3.original_name
assert row.file[2]['visible_name'] == user_file_2.original_name
del row.file[0]['visible_name']
del row.file[1]['visible_name']
del row.file[2]['visible_name']
assert row.file[0] == user_file_1.serialize()
assert row.file[1] == user_file_3.serialize()
assert row.file[2] == user_file_2.serialize()
row = row_handler.update_row(user=user, table=table, row_id=row.id, values={
'file': [
{'name': user_file_1.name, 'visible_name': 'not_original.jpg'},
]
}, model=model)
assert row.file[0]['visible_name'] == 'not_original.jpg'
del row.file[0]['visible_name']
assert row.file[0] == user_file_1.serialize()
assert model.objects.all().count() == 3
field_handler.delete_field(user=user, field=file)
assert FileField.objects.all().count() == 0
model.objects.all().delete()
text = field_handler.create_field(user=user, table=table, type_name='text',
name='Text')
model = table.get_model(attribute_names=True)
row = row_handler.create_row(user=user, table=table, values={
'text': 'Some random text'
}, model=model)
row_handler.create_row(user=user, table=table, values={
'text': '["Not compatible"]'
}, model=model)
row_handler.create_row(user=user, table=table, values={
'text': json.dumps(user_file_1.serialize())
}, model=model)
file = field_handler.update_field(user=user, table=table, field=text,
new_type_name='file', name='File')
model = table.get_model(attribute_names=True)
results = model.objects.all()
assert results[0].file == []
assert results[1].file == []
assert results[2].file == []
row_handler.update_row(user=user, table=table, row_id=row.id, values={
'file': [
{'name': user_file_1.name, 'visible_name': 'not_original.jpg'},
]
}, model=model)
field_handler.update_field(user=user, table=table, field=file,
new_type_name='text', name='text')
model = table.get_model(attribute_names=True)
results = model.objects.all()
assert results[0].text is None
assert results[1].text is None
assert results[2].text is None
def test_can_convert_between_all_fields(data_fixture):
"""
A nuclear option test turned off by default to help verify changes made to
field conversions work in every possible conversion scenario. This test checks
is possible to convert from every possible field to every other possible field
including converting to themselves. It only checks that the conversion does not
raise any exceptions.
"""
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user)
table = data_fixture.create_database_table(database=database, user=user)
link_table = data_fixture.create_database_table(database=database,
user=user)
data_fixture.create_text_field(table=link_table,
name="text_field",
primary=True)
handler = FieldHandler()
row_handler = RowHandler()
fake = Faker()
model = table.get_model()
cache = {}
# Make a blank row to test empty field conversion also.
model.objects.create(**{})
second_row_with_values = model.objects.create(**{})
# Some baserow field types have multiple different 'modes' which result in
# different conversion behaviour or entirely different database columns being
# created. Here the kwargs which control these modes are enumerated so we can then
# generate every possible type of conversion.
all_possible_kwargs_per_type = construct_all_possible_field_kwargs(
link_table)
i = 1
for field_type_name, all_possible_kwargs in all_possible_kwargs_per_type.items(
):
for kwargs in all_possible_kwargs:
for inner_field_type_name in field_type_registry.get_types():
for inner_kwargs in all_possible_kwargs_per_type[
inner_field_type_name]:
field_type = field_type_registry.get(field_type_name)
from_field = handler.create_field(
user=user,
table=table,
type_name=field_type_name,
**kwargs,
)
random_value = field_type.random_value(
from_field, fake, cache)
if isinstance(random_value, date):
# Faker produces subtypes of date / datetime which baserow
# does not want, instead just convert to str.
random_value = str(random_value)
row_handler.update_row(
user=user,
table=table,
row_id=second_row_with_values.id,
values={f"field_{from_field.id}": random_value},
)
handler.update_field(
user=user,
field=from_field,
new_type_name=inner_field_type_name,
**inner_kwargs,
)
i = i + 1
def test_single_select_field_type_rows(data_fixture,
django_assert_num_queries):
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user,
name="Placeholder")
table = data_fixture.create_database_table(name="Example",
database=database)
other_select_option = data_fixture.create_select_option()
field_handler = FieldHandler()
row_handler = RowHandler()
field = field_handler.create_field(
user=user,
table=table,
type_name="single_select",
select_options=[
{
"value": "Option 1",
"color": "red"
},
{
"value": "Option 2",
"color": "blue"
},
],
)
with pytest.raises(ValidationError):
row_handler.create_row(user=user,
table=table,
values={f"field_{field.id}": 999999})
with pytest.raises(ValidationError):
row_handler.create_row(
user=user,
table=table,
values={f"field_{field.id}": other_select_option.id})
select_options = field.select_options.all()
row = row_handler.create_row(
user=user,
table=table,
values={f"field_{field.id}": select_options[0].id})
assert getattr(row, f"field_{field.id}").id == select_options[0].id
assert getattr(row, f"field_{field.id}").value == select_options[0].value
assert getattr(row, f"field_{field.id}").color == select_options[0].color
assert getattr(row, f"field_{field.id}_id") == select_options[0].id
field = field_handler.update_field(
user=user,
field=field,
select_options=[
{
"value": "Option 3",
"color": "orange"
},
{
"value": "Option 4",
"color": "purple"
},
],
)
select_options = field.select_options.all()
row_2 = row_handler.create_row(
user=user,
table=table,
values={f"field_{field.id}": select_options[0].id})
assert getattr(row_2, f"field_{field.id}").id == select_options[0].id
assert getattr(row_2, f"field_{field.id}").value == select_options[0].value
assert getattr(row_2, f"field_{field.id}").color == select_options[0].color
assert getattr(row_2, f"field_{field.id}_id") == select_options[0].id
row_3 = row_handler.create_row(
user=user,
table=table,
values={f"field_{field.id}": select_options[1].id})
assert getattr(row_3, f"field_{field.id}").id == select_options[1].id
assert getattr(row_3, f"field_{field.id}_id") == select_options[1].id
row_4 = row_handler.create_row(
user=user,
table=table,
values={f"field_{field.id}": select_options[0].id})
assert getattr(row_4, f"field_{field.id}").id == select_options[0].id
assert getattr(row_4, f"field_{field.id}_id") == select_options[0].id
model = table.get_model()
with django_assert_num_queries(2):
rows = list(model.objects.all().enhance_by_fields())
assert getattr(rows[0], f"field_{field.id}") is None
assert getattr(rows[1], f"field_{field.id}").id == select_options[0].id
assert getattr(rows[2], f"field_{field.id}").id == select_options[1].id
assert getattr(rows[3], f"field_{field.id}").id == select_options[0].id
row.refresh_from_db()
assert getattr(row, f"field_{field.id}") is None
assert getattr(row, f"field_{field.id}_id") is None
field = field_handler.update_field(user=user,
field=field,
new_type_name="text")
assert field.select_options.all().count() == 0
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
assert getattr(rows[0], f"field_{field.id}") is None
assert getattr(rows[1], f"field_{field.id}") == "Option 3"
assert getattr(rows[2], f"field_{field.id}") == "Option 4"
assert getattr(rows[3], f"field_{field.id}") == "Option 3"
field = field_handler.update_field(
user=user,
field=field,
new_type_name="single_select",
select_options=[
{
"value": "Option 2",
"color": "blue"
},
{
"value": "option 3",
"color": "purple"
},
],
)
assert field.select_options.all().count() == 2
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
select_options = field.select_options.all()
assert getattr(rows[0], f"field_{field.id}") is None
assert getattr(rows[1], f"field_{field.id}").id == select_options[1].id
assert getattr(rows[2], f"field_{field.id}") is None
assert getattr(rows[3], f"field_{field.id}").id == select_options[1].id
row_4 = row_handler.update_row(user=user,
table=table,
row_id=row_4.id,
values={f"field_{field.id}": None})
assert getattr(row_4, f"field_{field.id}") is None
assert getattr(row_4, f"field_{field.id}_id") is None
field = field_handler.update_field(user=user,
field=field,
new_type_name="text")
assert field.select_options.all().count() == 0
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
assert getattr(rows[0], f"field_{field.id}") is None
assert getattr(rows[1], f"field_{field.id}") == "option 3"
assert getattr(rows[2], f"field_{field.id}") is None
assert getattr(rows[3], f"field_{field.id}") is None
field = field_handler.update_field(user=user,
field=field,
new_type_name="single_select")
assert field.select_options.all().count() == 0
model = table.get_model()
rows = model.objects.all().enhance_by_fields()
assert getattr(rows[0], f"field_{field.id}") is None
assert getattr(rows[1], f"field_{field.id}") is None
assert getattr(rows[2], f"field_{field.id}") is None
assert getattr(rows[3], f"field_{field.id}") is None
def test_update_row(send_mock, data_fixture):
user = data_fixture.create_user()
user_2 = data_fixture.create_user()
table = data_fixture.create_database_table(name="Car", user=user)
name_field = data_fixture.create_text_field(table=table,
name="Name",
text_default="Test")
speed_field = data_fixture.create_number_field(table=table,
name="Max speed",
number_negative=True)
price_field = data_fixture.create_number_field(
table=table,
name="Price",
number_type="DECIMAL",
number_decimal_places=2,
number_negative=False,
)
handler = RowHandler()
row = handler.create_row(user=user, table=table)
with pytest.raises(UserNotInGroup):
handler.update_row(user=user_2, table=table, row_id=row.id, values={})
with pytest.raises(RowDoesNotExist):
handler.update_row(user=user, table=table, row_id=99999, values={})
with pytest.raises(ValidationError):
handler.update_row(user=user,
table=table,
row_id=row.id,
values={price_field.id: -10.99})
with patch("baserow.contrib.database.rows.signals.before_row_update.send"
) as before_send_mock:
handler.update_row(
user=user,
table=table,
row_id=row.id,
values={
name_field.id: "Tesla",
speed_field.id: 240,
f"field_{price_field.id}": 59999.99,
},
)
row.refresh_from_db()
assert getattr(row, f"field_{name_field.id}") == "Tesla"
assert getattr(row, f"field_{speed_field.id}") == 240
assert getattr(row, f"field_{price_field.id}") == Decimal("59999.99")
before_send_mock.assert_called_once()
assert before_send_mock.call_args[1]["row"].id == row.id
assert before_send_mock.call_args[1]["user"].id == user.id
assert before_send_mock.call_args[1]["table"].id == table.id
assert before_send_mock.call_args[1]["model"]._generated_table_model
send_mock.assert_called_once()
assert send_mock.call_args[1]["row"].id == row.id
assert send_mock.call_args[1]["user"].id == user.id
assert send_mock.call_args[1]["table"].id == table.id
assert send_mock.call_args[1]["model"]._generated_table_model
assert send_mock.call_args[1][
"before_return"] == before_send_mock.return_value
def test_file_field_type(data_fixture, user_tables_in_separate_db):
user = data_fixture.create_user()
table = data_fixture.create_database_table(user=user)
user_file_1 = data_fixture.create_user_file()
user_file_2 = data_fixture.create_user_file()
user_file_3 = data_fixture.create_user_file()
field_handler = FieldHandler()
row_handler = RowHandler()
file = field_handler.create_field(user=user,
table=table,
type_name="file",
name="File")
assert FileField.objects.all().count() == 1
model = table.get_model(attribute_names=True)
with pytest.raises(ValidationError):
row_handler.create_row(user=user,
table=table,
values={"file": "not_a_json"},
model=model)
with pytest.raises(ValidationError):
row_handler.create_row(user=user,
table=table,
values={"file": {}},
model=model)
with pytest.raises(ValidationError):
row_handler.create_row(user=user,
table=table,
values={"file": [{
"no_name": "test"
}]},
model=model)
with pytest.raises(InvalidUserFileNameError):
row_handler.create_row(
user=user,
table=table,
values={"file": [{
"name": "wrongfilename.jpg"
}]},
model=model,
)
with pytest.raises(UserFileDoesNotExist):
row_handler.create_row(
user=user,
table=table,
values={"file": [{
"name": "file_name.jpg"
}]},
model=model,
)
row = row_handler.create_row(
user=user,
table=table,
values={"file": [{
"name": user_file_1.name
}]},
model=model,
)
assert row.file[0]["visible_name"] == user_file_1.original_name
del row.file[0]["visible_name"]
assert row.file[0] == user_file_1.serialize()
row = row_handler.create_row(
user=user,
table=table,
values={
"file": [
{
"name": user_file_2.name
},
{
"name": user_file_1.name
},
{
"name": user_file_1.name
},
]
},
model=model,
)
assert row.file[0]["visible_name"] == user_file_2.original_name
assert row.file[1]["visible_name"] == user_file_1.original_name
assert row.file[2]["visible_name"] == user_file_1.original_name
del row.file[0]["visible_name"]
del row.file[1]["visible_name"]
del row.file[2]["visible_name"]
assert row.file[0] == user_file_2.serialize()
assert row.file[1] == user_file_1.serialize()
assert row.file[2] == user_file_1.serialize()
row = row_handler.create_row(
user=user,
table=table,
values={
"file": [
{
"name": user_file_1.name
},
{
"name": user_file_3.name
},
{
"name": user_file_2.name
},
]
},
model=model,
)
assert row.file[0]["visible_name"] == user_file_1.original_name
assert row.file[1]["visible_name"] == user_file_3.original_name
assert row.file[2]["visible_name"] == user_file_2.original_name
del row.file[0]["visible_name"]
del row.file[1]["visible_name"]
del row.file[2]["visible_name"]
assert row.file[0] == user_file_1.serialize()
assert row.file[1] == user_file_3.serialize()
assert row.file[2] == user_file_2.serialize()
row = row_handler.update_row(
user=user,
table=table,
row_id=row.id,
values={
"file": [
{
"name": user_file_1.name,
"visible_name": "not_original.jpg"
},
]
},
model=model,
)
assert row.file[0]["visible_name"] == "not_original.jpg"
del row.file[0]["visible_name"]
assert row.file[0] == user_file_1.serialize()
assert model.objects.all().count() == 3
field_handler.delete_field(user=user, field=file)
assert FileField.objects.all().count() == 0
model.objects.all().delete()
text = field_handler.create_field(user=user,
table=table,
type_name="text",
name="Text")
model = table.get_model(attribute_names=True)
row = row_handler.create_row(user=user,
table=table,
values={"text": "Some random text"},
model=model)
row_handler.create_row(user=user,
table=table,
values={"text": '["Not compatible"]'},
model=model)
row_handler.create_row(
user=user,
table=table,
values={"text": json.dumps(user_file_1.serialize())},
model=model,
)
file = field_handler.update_field(user=user,
table=table,
field=text,
new_type_name="file",
name="File")
model = table.get_model(attribute_names=True)
results = model.objects.all()
assert results[0].file == []
assert results[1].file == []
assert results[2].file == []
row_handler.update_row(
user=user,
table=table,
row_id=row.id,
values={
"file": [
{
"name": user_file_1.name,
"visible_name": "not_original.jpg"
},
]
},
model=model,
)
field_handler.update_field(user=user,
table=table,
field=file,
new_type_name="text",
name="text")
model = table.get_model(attribute_names=True)
results = model.objects.all()
assert results[0].text is None
assert results[1].text is None
assert results[2].text is None
