search_path_test.go

// Copyright 2016 The Cockroach Authors.
//
// Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt.
//
// As of the Change Date specified in that file, in accordance with
// the Business Source License, use of this software will be governed
// by the Apache License, Version 2.0, included in the file
// licenses/APL.txt.

package sessiondata

import (
	"reflect"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
)

// Tests the implied search path when no temporary schema has been created
// by the session.
func TestImpliedSearchPath(t *testing.T) {
	testTempSchemaName := `test_temp_schema`

	testCases := []struct {
		explicitSearchPath                                             []string
		expectedSearchPath                                             []string
		expectedSearchPathWithoutImplicitPgSchemas                     []string
		expectedSearchPathWhenTemporarySchemaExists                    []string
		expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists []string
	}{
		{[]string{}, /* explicitSearchPath */
			[]string{`pg_catalog`}, /* expectedSearchPath */
			[]string{},             /* expectedSearchPathWithoutImplicitPgSchemas */
			[]string{testTempSchemaName, `pg_catalog`}, /* expectedSearchPathWhenTemporarySchemaExists */
			[]string{}, /* expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists */
		},
		{[]string{`pg_catalog`}, /* explicitSearchPath */
			[]string{`pg_catalog`},                     /* expectedSearchPath */
			[]string{`pg_catalog`},                     /* expectedSearchPathWithoutImplicitPgSchemas */
			[]string{testTempSchemaName, `pg_catalog`}, /* expectedSearchPathWhenTemporarySchemaExists */
			[]string{`pg_catalog`},                     /* expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists */

		},
		{[]string{`pg_catalog`, `pg_temp`}, /* explicitSearchPath */
			[]string{`pg_catalog`},                     /* expectedSearchPath */
			[]string{`pg_catalog`},                     /* expectedSearchPathWithoutImplicitPgSchemas */
			[]string{`pg_catalog`, testTempSchemaName}, /* expectedSearchPathWhenTemporarySchemaExists */
			[]string{`pg_catalog`, testTempSchemaName}, /* expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists */
		},
		{[]string{`pg_temp`, `pg_catalog`}, /* explicitSearchPath */
			[]string{`pg_catalog`},                     /* expectedSearchPath */
			[]string{`pg_catalog`},                     /* expectedSearchPathWithoutImplicitPgSchemas */
			[]string{testTempSchemaName, `pg_catalog`}, /* expectedSearchPathWhenTemporarySchemaExists */
			[]string{testTempSchemaName, `pg_catalog`}, /* expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists */
		},
		{[]string{`foobar`, `pg_catalog`}, /* explicitSearchPath */
			[]string{`foobar`, `pg_catalog`},                     /* expectedSearchPath */
			[]string{`foobar`, `pg_catalog`},                     /* expectedSearchPathWithoutImplicitPgSchemas */
			[]string{testTempSchemaName, `foobar`, `pg_catalog`}, /* expectedSearchPathWhenTemporarySchemaExists */
			[]string{`foobar`, `pg_catalog`},                     /* expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists */

		},
		{[]string{`foobar`, `pg_temp`}, /* explicitSearchPath */
			[]string{`pg_catalog`, `foobar`},                     /* expectedSearchPath */
			[]string{`foobar`},                                   /* expectedSearchPathWithoutImplicitPgSchemas */
			[]string{`pg_catalog`, `foobar`, testTempSchemaName}, /* expectedSearchPathWhenTemporarySchemaExists */
			[]string{`foobar`, testTempSchemaName},               /* expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists */

		},
		{[]string{`foobar`}, /* explicitSearchPath */
			[]string{`pg_catalog`, `foobar`},                     /* expectedSearchPath */
			[]string{`foobar`},                                   /* expectedSearchPathWithoutImplicitPgSchemas */
			[]string{testTempSchemaName, `pg_catalog`, `foobar`}, /* expectedSearchPathWhenTemporarySchemaExists */
			[]string{`foobar`},                                   /* expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists */
		},
	}

	for tcNum, tc := range testCases {
		t.Run(strings.Join(tc.explicitSearchPath, ","), func(t *testing.T) {
			searchPath := MakeSearchPath(tc.explicitSearchPath, DefaultTemporarySchema)
			actualSearchPath := make([]string, 0)
			iter := searchPath.Iter()
			for p, ok := iter.Next(); ok; p, ok = iter.Next() {
				actualSearchPath = append(actualSearchPath, p)
			}
			if !reflect.DeepEqual(tc.expectedSearchPath, actualSearchPath) {
				t.Errorf(
					`#%d: Expected search path to be %#v, but was %#v.`,
					tcNum,
					tc.expectedSearchPath,
					actualSearchPath,
				)
			}
		})

		t.Run(strings.Join(tc.explicitSearchPath, ",")+"/no-pg-schemas", func(t *testing.T) {
			searchPath := MakeSearchPath(tc.explicitSearchPath, DefaultTemporarySchema)
			actualSearchPath := make([]string, 0)
			iter := searchPath.IterWithoutImplicitPGSchemas()
			for p, ok := iter.Next(); ok; p, ok = iter.Next() {
				actualSearchPath = append(actualSearchPath, p)
			}
			if !reflect.DeepEqual(tc.expectedSearchPathWithoutImplicitPgSchemas, actualSearchPath) {
				t.Errorf(
					`#%d: Expected search path to be %#v, but was %#v.`,
					tcNum,
					tc.expectedSearchPathWithoutImplicitPgSchemas,
					actualSearchPath,
				)
			}
		})

		t.Run(strings.Join(tc.explicitSearchPath, ",")+"/temp-schema-exists", func(t *testing.T) {
			searchPath := MakeSearchPath(tc.explicitSearchPath, testTempSchemaName)
			actualSearchPath := make([]string, 0)
			iter := searchPath.Iter()
			for p, ok := iter.Next(); ok; p, ok = iter.Next() {
				actualSearchPath = append(actualSearchPath, p)
			}
			if !reflect.DeepEqual(tc.expectedSearchPathWhenTemporarySchemaExists, actualSearchPath) {
				t.Errorf(
					`#%d: Expected search path to be %#v, but was %#v.`,
					tcNum,
					tc.expectedSearchPathWhenTemporarySchemaExists,
					actualSearchPath,
				)
			}
		})

		t.Run(strings.Join(tc.explicitSearchPath, ",")+"/no-pg-schemas/temp-schema-exists", func(t *testing.T) {
			searchPath := MakeSearchPath(tc.explicitSearchPath, testTempSchemaName)
			actualSearchPath := make([]string, 0)
			iter := searchPath.IterWithoutImplicitPGSchemas()
			for p, ok := iter.Next(); ok; p, ok = iter.Next() {
				actualSearchPath = append(actualSearchPath, p)
			}
			if !reflect.DeepEqual(tc.expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists, actualSearchPath) {
				t.Errorf(
					`#%d: Expected search path to be %#v, but was %#v.`,
					tcNum,
					tc.expectedSearchPathWithoutImplicitPgSchemasWhenTempSchemaExists,
					actualSearchPath,
				)
			}
		})
	}
}

func TestSearchPathEquals(t *testing.T) {
	testTempSchemaName := `test_temp_schema`

	a1 := MakeSearchPath([]string{"x", "y", "z"}, DefaultTemporarySchema)
	a2 := MakeSearchPath([]string{"x", "y", "z"}, DefaultTemporarySchema)
	assert.True(t, a1.Equals(&a1))
	assert.True(t, a2.Equals(&a2))

	assert.True(t, a1.Equals(&a2))
	assert.True(t, a2.Equals(&a1))

	b := MakeSearchPath([]string{"x", "z", "y"}, DefaultTemporarySchema)
	assert.False(t, a1.Equals(&b))

	c1 := MakeSearchPath([]string{"x", "y", "z", "pg_catalog"}, DefaultTemporarySchema)
	c2 := MakeSearchPath([]string{"x", "y", "z", "pg_catalog"}, DefaultTemporarySchema)
	assert.True(t, c1.Equals(&c2))
	assert.False(t, a1.Equals(&c1))

	d := MakeSearchPath([]string{"x"}, DefaultTemporarySchema)
	assert.False(t, a1.Equals(&d))

	e1 := MakeSearchPath([]string{"x", "y", "z"}, testTempSchemaName)
	e2 := MakeSearchPath([]string{"x", "y", "z"}, testTempSchemaName)
	assert.True(t, e1.Equals(&e1))
	assert.True(t, e1.Equals(&e2))
	assert.False(t, e1.Equals(&a1))

	f := MakeSearchPath([]string{"x", "z", "y"}, testTempSchemaName)
	assert.False(t, e1.Equals(&f))

	g := MakeSearchPath([]string{"x", "y", "z", "pg_temp"}, DefaultTemporarySchema)
	assert.False(t, e1.Equals(&g))
	assert.False(t, g.Equals(&c1))

	h := MakeSearchPath([]string{"x", "y", "z", "pg_temp"}, testTempSchemaName)
	assert.False(t, g.Equals(&h))

	i := MakeSearchPath([]string{"x", "y", "z", "pg_temp", "pg_catalog"}, testTempSchemaName)
	assert.False(t, i.Equals(&h))
	assert.False(t, i.Equals(&c1))
}

func TestWithTemporarySchema(t *testing.T) {
	testTempSchemaName := `test_temp_schema`

	sp := MakeSearchPath([]string{"x", "y", "z"}, DefaultTemporarySchema)
	sp = sp.UpdatePaths([]string{"x", "pg_catalog"})
	assert.True(t, sp.GetTemporarySchema() == DefaultTemporarySchema)

	sp = sp.WithTemporarySchemaName(testTempSchemaName)
	sp = sp.UpdatePaths([]string{"pg_catalog"})
	assert.True(t, sp.GetTemporarySchema() == testTempSchemaName)

	sp = sp.UpdatePaths([]string{"x", "pg_temp"})
	assert.True(t, sp.GetTemporarySchema() == testTempSchemaName)
}