fix(test): use unique namespace names per integration test

TearDownTest cannot remove root-owned Spark directories, so tests
that share namespace names collide when a later test tries to create
a namespace that already exists from a prior test. Give each test
its own namespace to avoid ordering dependencies.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: tanmayrauth

catalog/hadoop/hadoop_integration_test.go

@@ -89,19 +89,19 @@ func (s *HadoopIntegrationSuite) sparkSQL(sql string) string {
 func (s *HadoopIntegrationSuite) TestGoCreateSparkDescribe() {
 	// Create namespace from Go so the directory is owned by the runner
 	// process and Go can create table subdirectories inside it.
-	err := s.cat.CreateNamespace(s.ctx, []string{"integration_ns"}, nil)
+	err := s.cat.CreateNamespace(s.ctx, []string{"describe_ns"}, nil)
 	s.Require().NoError(err)
 
 	schema := iceberg.NewSchema(1,
 		iceberg.NestedField{ID: 1, Name: "id", Type: iceberg.PrimitiveTypes.Int64, Required: true},
 		iceberg.NestedField{ID: 2, Name: "name", Type: iceberg.PrimitiveTypes.String, Required: false},
 	)
 
-	tbl, err := s.cat.CreateTable(s.ctx, []string{"integration_ns", "go_created_table"}, schema)
+	tbl, err := s.cat.CreateTable(s.ctx, []string{"describe_ns", "go_created_table"}, schema)
 	s.Require().NoError(err)
 	s.NotNil(tbl)
 
-	output := s.sparkSQL("DESCRIBE TABLE hadoop_test.integration_ns.go_created_table")
+	output := s.sparkSQL("DESCRIBE TABLE hadoop_test.describe_ns.go_created_table")
 	s.Contains(output, "id")
 	s.Contains(output, "name")
 }
@@ -110,10 +110,10 @@ func (s *HadoopIntegrationSuite) TestGoCreateSparkDescribe() {
 // Go and verifies schema and metadata are consistent.
 func (s *HadoopIntegrationSuite) TestSparkCreateGoLoad() {
 	// Spark creates both namespace and table — Go only reads here.
-	s.sparkSQL("CREATE NAMESPACE IF NOT EXISTS hadoop_test.integration_ns")
-	s.sparkSQL("CREATE TABLE hadoop_test.integration_ns.spark_created_table (age INT, city STRING) USING iceberg")
+	s.sparkSQL("CREATE NAMESPACE IF NOT EXISTS hadoop_test.load_ns")
+	s.sparkSQL("CREATE TABLE hadoop_test.load_ns.spark_created_table (age INT, city STRING) USING iceberg")
 
-	tbl, err := s.cat.LoadTable(s.ctx, []string{"integration_ns", "spark_created_table"})
+	tbl, err := s.cat.LoadTable(s.ctx, []string{"load_ns", "spark_created_table"})
 	s.Require().NoError(err)
 	s.NotNil(tbl)
 
@@ -130,32 +130,32 @@ func (s *HadoopIntegrationSuite) TestSparkCreateGoLoad() {
 // TestGoCreateSparkSelect creates a table from Go, then runs a SELECT
 // from Spark to confirm the table is queryable (should return empty).
 func (s *HadoopIntegrationSuite) TestGoCreateSparkSelect() {
-	err := s.cat.CreateNamespace(s.ctx, []string{"integration_ns"}, nil)
+	err := s.cat.CreateNamespace(s.ctx, []string{"select_ns"}, nil)
 	s.Require().NoError(err)
 
 	schema := iceberg.NewSchema(1,
 		iceberg.NestedField{ID: 1, Name: "value", Type: iceberg.PrimitiveTypes.Int32, Required: true},
 	)
 
-	_, err = s.cat.CreateTable(s.ctx, []string{"integration_ns", "go_select_table"}, schema)
+	_, err = s.cat.CreateTable(s.ctx, []string{"select_ns", "go_select_table"}, schema)
 	s.Require().NoError(err)
 
-	output := s.sparkSQL("SELECT * FROM hadoop_test.integration_ns.go_select_table")
+	output := s.sparkSQL("SELECT * FROM hadoop_test.select_ns.go_select_table")
 	s.Contains(output, "value")
 }
 
 // TestGoCheckTableExistsForSparkTable verifies that CheckTableExists
 // returns true for a table created by Spark.
 func (s *HadoopIntegrationSuite) TestGoCheckTableExistsForSparkTable() {
 	// Spark creates both namespace and table — Go only checks existence.
-	s.sparkSQL("CREATE NAMESPACE IF NOT EXISTS hadoop_test.integration_ns")
-	s.sparkSQL("CREATE TABLE hadoop_test.integration_ns.spark_exists_table (x INT) USING iceberg")
+	s.sparkSQL("CREATE NAMESPACE IF NOT EXISTS hadoop_test.exists_ns")
+	s.sparkSQL("CREATE TABLE hadoop_test.exists_ns.spark_exists_table (x INT) USING iceberg")
 
-	exists, err := s.cat.CheckTableExists(s.ctx, []string{"integration_ns", "spark_exists_table"})
+	exists, err := s.cat.CheckTableExists(s.ctx, []string{"exists_ns", "spark_exists_table"})
 	s.Require().NoError(err)
 	s.True(exists)
 
-	exists, err = s.cat.CheckTableExists(s.ctx, []string{"integration_ns", "no_such_table"})
+	exists, err = s.cat.CheckTableExists(s.ctx, []string{"exists_ns", "no_such_table"})
 	s.Require().NoError(err)
 	s.False(exists)
 }