def test_delete_table(engine_with_schema, if_exists): engine, schema = engine_with_schema table_name = "test_delete_table" tables.create_mathesar_table(table_name, schema, [], engine) tables.delete_table(table_name, schema, engine, if_exists=if_exists) with pytest.raises(NoSuchTableError): tables.reflect_table(table_name, schema, engine)
def test_update_table_column_types_infers_non_default_types(engine_with_schema): col1 = Column("col1", String) col2 = Column("col2", String) column_list = [col1, col2] engine, schema = engine_with_schema table_name = "table_with_columns" tables.create_mathesar_table( table_name, schema, column_list, engine ) with patch.object(tables.inference, "infer_column_type") as mock_infer: tables.update_table_column_types( schema, table_name, engine ) expect_calls = [ call( schema, table_name, col1.name, engine, ), call( schema, table_name, col2.name, engine, ), ] mock_infer.assert_has_calls(expect_calls)
def test_table_creation_doesnt_reuse_defaults(engine_with_schema): column_list = [] engine, schema = engine_with_schema t1 = tables.create_mathesar_table("t1", schema, column_list, engine) t2 = tables.create_mathesar_table("t2", schema, column_list, engine) assert all( [ c1.name == c2.name and c1 != c2 for c1, c2 in zip(t1.columns, t2.columns) ] )
def test_delete_schema_restricted(engine): test_schema = "test_delete_schema_restricted" test_table = "test_delete_schema_restricted_table" schemas.create_schema(test_schema, engine) tables.create_mathesar_table(test_table, test_schema, [], engine) with pytest.raises(DependentObjectsStillExist): schemas.delete_schema(test_schema, engine) current_schemas = schemas.get_mathesar_schemas(engine) assert test_schema in current_schemas
def test_update_table_column_types_skips_pkey_columns(engine_with_schema): column_list = [Column("checkcol", String, primary_key=True)] engine, schema = engine_with_schema table_name = "t1" tables.create_mathesar_table( table_name, schema, column_list, engine ) with patch.object(tables.inference, "infer_column_type") as mock_infer: tables.update_table_column_types( schema, table_name, engine ) mock_infer.assert_not_called()
def test_infer_table_column_types_doesnt_touch_defaults(engine_with_schema): column_list = [] engine, schema = engine_with_schema table_name = "t1" tables.create_mathesar_table( table_name, schema, column_list, engine ) with patch.object(tables.inference, "infer_column_type") as mock_infer: tables.update_table_column_types( schema, table_name, engine ) mock_infer.assert_not_called()
def test_rename_column_foreign_keys(engine_with_schema): engine, schema = engine_with_schema table_name = "table_to_split" columns_list = [Column("Filler 1", Integer), Column("Filler 2", Integer)] tables.create_mathesar_table(table_name, schema, columns_list, engine) extracted, remainder, fk_name = tables.extract_columns_from_table( table_name, ["Filler 1"], "Extracted", "Remainder", schema, engine) new_fk_name = "new_" + fk_name remainder = _rename_column(schema, remainder.name, fk_name, new_fk_name, engine) fk = list(remainder.foreign_keys)[0] assert fk.parent.name == new_fk_name assert fk.column.table.name == extracted.name
def test_delete_table_restricted_foreign_key(engine_with_schema): engine, schema = engine_with_schema table_name = "test_delete_table_restricted_foreign_key" related_table_name = "test_delete_table_restricted_foreign_key_related" table = tables.create_mathesar_table(table_name, schema, [], engine) _create_related_table(related_table_name, table, schema, engine) with pytest.raises(DependentObjectsStillExist): tables.delete_table(table_name, schema, engine, cascade=False)
def test_multi_db_tables(engine, multi_db_engine, client): schema_name = "test_multi_db_tables_schema" test_tables = ["test_table_1", "test_table_2"] for table_name in test_tables: tables.create_mathesar_table(table_name, schema_name, [], engine) tables.create_mathesar_table("multi_db_" + table_name, schema_name, [], multi_db_engine) cache.clear() response = client.get('/api/v0/tables/') response_tables = [s['name'] for s in response.json()['results']] assert response.status_code == 200 expected_tables = test_tables + ["multi_db_" + s for s in test_tables] for table_name in expected_tables: assert table_name in response_tables # We have to delete the schema to not break later tests with engine.begin() as conn: conn.execute(DropSchema(schema_name, cascade=True))
def test_delete_table_cascade_foreign_key(engine_with_schema): engine, schema = engine_with_schema table_name = "test_delete_table_cascade_foreign_key" related_table_name = "test_delete_table_cascade_foreign_key_related" table = tables.create_mathesar_table(table_name, schema, [], engine) related_table = _create_related_table(related_table_name, table, schema, engine) tables.delete_table(table_name, schema, engine, cascade=True) related_table = tables.reflect_table(related_table.name, schema, engine) assert len(related_table.foreign_keys) == 0
def test_delete_schema_cascade(engine): test_schema = "test_delete_schema_cascade" test_table = "test_delete_schema_cascade_table" schemas.create_schema(test_schema, engine) table = tables.create_mathesar_table(test_table, test_schema, [], engine) schemas.delete_schema(test_schema, engine, cascade=True) current_schemas = schemas.get_mathesar_schemas(engine) assert test_schema not in current_schemas with pytest.raises(NoSuchTableError): tables.reflect_table(table.name, test_schema, engine)
def test_rename_table_foreign_key(engine_with_schema): engine, schema = engine_with_schema table_name = "test_rename_table_foreign_key" new_table_name = "test_rename_table_foreign_key_new" related_table_name = "test_rename_table_foreign_key_related" table = tables.create_mathesar_table(table_name, schema, [], engine) related_table = _create_related_table(related_table_name, table, schema, engine) tables.rename_table(table_name, schema, engine, new_table_name) related_table = tables.reflect_table(related_table_name, schema, engine) fk = list(related_table.foreign_keys)[0] assert fk.column.table.name == new_table_name
def test_rename_table(engine_with_schema): engine, schema = engine_with_schema table_name = "test_rename_table" new_table_name = "test_rename_table_new" old_table = tables.create_mathesar_table(table_name, schema, [], engine) old_oid = tables.get_oid_from_table(old_table.name, old_table.schema, engine) tables.rename_table(table_name, schema, engine, new_table_name) new_table = tables.reflect_table(new_table_name, schema, engine) new_oid = tables.get_oid_from_table(new_table.name, new_table.schema, engine) assert old_oid == new_oid assert new_table.name == new_table_name with pytest.raises(NoSuchTableError): tables.reflect_table(table_name, schema, engine)
def _create_related_table(schema, related_schema, table, related_table, engine): schemas.create_schema(schema, engine) table = tables.create_mathesar_table(table, schema, [], engine) schemas.create_schema(related_schema, engine) metadata = MetaData(schema=related_schema, bind=engine) related_table = Table( related_table, metadata, Column('id', Integer, ForeignKey(table.c[constants.ID]))) related_table.create() related_table = tables.reflect_table(related_table.name, related_schema, engine) fk = list(related_table.foreign_keys)[0] assert fk.column.table.schema == schema return related_table
def test_rename_column_sequence(engine_with_schema): old_col_name = constants.ID new_col_name = "new_" + constants.ID engine, schema = engine_with_schema table_name = "table_with_columns" table = tables.create_mathesar_table(table_name, schema, [], engine) with engine.begin() as conn: ins = table.insert() conn.execute(ins) table = _rename_column(schema, table_name, old_col_name, new_col_name, engine) with engine.begin() as conn: ins = table.insert() conn.execute(ins) slct = select(table) result = conn.execute(slct) new_value = result.fetchall()[-1][new_col_name] assert new_value == 2