fix the unix socket specs to use docker

Author: leafo

spec/pgmoon_unix_spec.moon

@@ -1,72 +1,127 @@
 import Postgres from require "pgmoon"
 
-SOCKET_PATH = "/var/run/postgresql/.s.PGSQL.5432"
-
--- Basic test to verify Unix socket support loads correctly
-describe "Unix socket support", ->
-  it "should choose nginx or luaposix when socket_path is provided", ->
-    pg = Postgres {
-      socket_path: "/tmp/test.sock"
-      user: "postgres"
-      database: "test"
-    }
-
-    if ngx and ngx.get_phase! != "init"
-      assert.equal "nginx", pg.sock_type
-    else
-      assert.equal "luaposix", pg.sock_type
-
-  it "should accept socket_path in configuration", ->
-    pg = Postgres {
-      socket_path: SOCKET_PATH
-      user: "postgres"
-      database: "test"
-    }
-
-    assert.equal SOCKET_PATH, pg.config.socket_path
-
-  it "should default to luasocket when no socket_path is provided", ->
-    pg = Postgres {
-      user: "postgres"
-      database: "test"
-    }
-
-    -- Should not be luaposix since no socket_path provided
-    assert.is_not.equal "luaposix", pg.sock_type
-
-  it "should have socket_path as nil in default config", ->
-    pg = Postgres {}
-    assert.is_nil pg.config.socket_path
-
-  it "should override socket_type when socket_path is provided", ->
-    -- Even if we explicitly set socket_type to something else,
-    -- providing socket_path should force luaposix
-    pg = Postgres {
-      socket_type: "luasocket"
-      socket_path: "/tmp/test.sock"
-      user: "postgres"
-      database: "test"
-    }
-
-    if ngx and ngx.get_phase! != "init"
-      assert.equal "nginx", pg.sock_type
-    else
-      assert.equal "luaposix", pg.sock_type
-
-  -- This test would require an actual Unix socket PostgreSQL server
-  -- Keeping it commented out for now
-  it "should connect via Unix socket", ->
-    pg = Postgres {
-      socket_path: SOCKET_PATH
-      user: "postgres"
-      database: "postgres"
-    }
-
-    success, err = pg\connect!
-    assert success, "Failed to connect: #{err}"
-
-    result, err = pg\query "SELECT 1 as test"
-    assert result, "Failed to query: #{err}"
-    assert.equal 1, result[1].test
-
-    pg\disconnect!
+import psql_unix, SOCKET_PATH, USER, PASSWORD, DB from require "spec.util"
+
+describe "pgmoon Unix socket with server", ->
+  setup ->
+    os.execute "spec/postgres.sh start unix"
+
+    r = { psql_unix "drop database if exists #{DB}" }
+    assert 0 == r[#r], "failed to execute psql_unix: drop database"
+
+    r = { psql_unix "create database #{DB}" }
+    assert 0 == r[#r], "failed to execute psql_unix: create database"
+
+  teardown ->
+    os.execute "spec/postgres.sh stop"
+
+  -- Test that socket_path configuration selects the right socket type
+  describe "socket type selection", ->
+    it "should choose luaposix when socket_path is provided outside nginx", ->
+      unless ngx
+        pg = Postgres {
+          socket_path: "/tmp/test.sock"
+          user: "postgres"
+          database: "test"
+        }
+        assert.equal "luaposix", pg.sock_type
+
+    it "should accept socket_path in configuration", ->
+      pg = Postgres {
+        socket_path: SOCKET_PATH
+        user: "postgres"
+        database: "test"
+      }
+      assert.equal SOCKET_PATH, pg.config.socket_path
+
+    it "should default to luasocket when no socket_path is provided", ->
+      pg = Postgres {
+        user: "postgres"
+        database: "test"
+      }
+      -- Should not be luaposix since no socket_path provided
+      assert.is_not.equal "luaposix", pg.sock_type
+
+    it "should have socket_path as nil in default config", ->
+      pg = Postgres {}
+      assert.is_nil pg.config.socket_path
+
+    it "should override socket_type when socket_path is provided", ->
+      pg = Postgres {
+        socket_type: "luasocket"
+        socket_path: "/tmp/test.sock"
+        user: "postgres"
+        database: "test"
+      }
+      if ngx and ngx.get_phase! != "init"
+        assert.equal "nginx", pg.sock_type
+      else
+        assert.equal "luaposix", pg.sock_type
+
+  -- Actual connection tests via Unix socket
+  describe "luaposix socket", ->
+    local pg
+
+    before_each ->
+      pg = Postgres {
+        socket_path: SOCKET_PATH
+        user: USER
+        password: PASSWORD
+        database: DB
+      }
+
+    after_each ->
+      pg\disconnect! if pg
+
+    it "connects via Unix socket", ->
+      success, err = pg\connect!
+      assert success, "Failed to connect: #{err}"
+
+      result, err = pg\query "SELECT 1 as test"
+      assert result, "Failed to query: #{err}"
+      assert.same { { test: 1 } }, result
+
+    it "creates and queries table", ->
+      assert pg\connect!
+
+      res = assert pg\query [[
+        create table unix_test (
+          id serial not null,
+          name text,
+          primary key (id)
+        )
+      ]]
+      assert.same true, res
+
+      res = assert pg\query [[
+        insert into unix_test (name) values ('hello') returning id, name
+      ]]
+      assert.same {
+        affected_rows: 1
+        { id: 1, name: "hello" }
+      }, res
+
+      res = assert pg\query [[
+        select * from unix_test
+      ]]
+      assert.same {
+        { id: 1, name: "hello" }
+      }, res
+
+      assert pg\query [[drop table unix_test]]
+
+    it "handles errors correctly", ->
+      assert pg\connect!
+
+      status, err = pg\query "select * from nonexistent_table"
+      assert.falsy status
+      assert.truthy err\match "does not exist"
+
+    it "can reconnect after disconnect", ->
+      do return pending "luaposix socket does not support reconnect on same instance"
+      assert pg\connect!
+      assert pg\query "select 1"
+      pg\disconnect!
+
+      assert pg\connect!
+      assert pg\query "select 1"

spec/postgres.sh

@@ -3,6 +3,7 @@ set -eo pipefail
 
 pgroot=$(pwd)/pgdata
 port=9999
+socket_dir="/tmp/pgmoon-test-socket"
 
 postgres_version=${DOCKER_POSTGRES_VERSION:-latest}
 
@@ -20,25 +21,52 @@ function makecerts {
 }
 
 function start {
+  # Stop any existing container first
+  docker stop pgmoon-test > /dev/null 2>&1 || true
+
   INIT_SCRIPT=""
+  VOLUME_MOUNT=""
+  PORT_MAPPING="-p 127.0.0.1:$port:5432/tcp"
 
   if [ "$1" = "ssl" ]; then
     INIT_SCRIPT="-v $(pwd)/spec/docker_enable_ssl.sh:/docker-entrypoint-initdb.d/docker_enable_ssl.sh"
   fi
 
+  if [ "$1" = "unix" ]; then
+    # Create socket directory if it doesn't exist
+    if [ ! -d "$socket_dir" ]; then
+      mkdir -p "$socket_dir"
+      chmod 777 "$socket_dir"
+    fi
+    VOLUME_MOUNT="-v $socket_dir:/var/run/postgresql"
+    # No TCP port mapping needed for unix socket mode
+    PORT_MAPPING=""
+  fi
+
   echo "$(tput setaf 4)Starting postgresql $postgres_version (docker run) $1 $(tput sgr0)"
   docker run --rm --name pgmoon-test \
-    -p 127.0.0.1:$port:5432/tcp \
+    $PORT_MAPPING \
     -e POSTGRES_PASSWORD=pgmoon \
     $INIT_SCRIPT \
+    $VOLUME_MOUNT \
     -d \
     postgres:$postgres_version > /dev/null
 
 
   # -v "$pgroot:/var/lib/postgresql/data" \ # this can be used to inspect logs since we'll have the server data dir available after the sever stops
 
   echo "$(tput setaf 4)Waiting for server to be ready$(tput sgr0)"
-  until (PGHOST=127.0.0.1 PGPORT=$port PGUSER=postgres PGPASSWORD=pgmoon psql -c 'SELECT pg_reload_conf()' 2> /dev/null); do :; done
+  if [ "$1" = "unix" ]; then
+    # For unix socket mode, wait until socket file appears and postgres is ready
+    until [ -S "$socket_dir/.s.PGSQL.5432" ]; do
+      sleep 0.1
+    done
+    until docker exec pgmoon-test pg_isready -U postgres > /dev/null 2>&1; do
+      sleep 0.1
+    done
+  else
+    until (PGHOST=127.0.0.1 PGPORT=$port PGUSER=postgres PGPASSWORD=pgmoon psql -c 'SELECT pg_reload_conf()' 2> /dev/null); do :; done
+  fi
   echo "$(tput setaf 4)Sever is ready$(tput sgr0)"
 }
 

spec/util.moon

@@ -5,10 +5,17 @@ USER = "postgres"
 PASSWORD = "pgmoon"
 DB = "pgmoon_test"
 
+SOCKET_DIR = "/tmp/pgmoon-test-socket"
+SOCKET_PATH = "#{SOCKET_DIR}/.s.PGSQL.5432"
+
 shell_escape = (str) -> str\gsub "'", "'\\''"
 
 psql = (query) ->
   os.execute "PGHOST='#{shell_escape HOST}' PGPORT='#{shell_escape PORT}' PGUSER='#{shell_escape USER}' PGPASSWORD='#{shell_escape PASSWORD}' psql -c '#{query}'"
 
+-- psql via unix socket using local psql with socket path
+psql_unix = (query) ->
+  os.execute "PGHOST='#{shell_escape SOCKET_DIR}' PGUSER='#{shell_escape USER}' PGPASSWORD='#{shell_escape PASSWORD}' psql -c '#{shell_escape query}'"
+
 
-{:psql, :HOST, :PORT, :USER, :PASSWORD, :DB }
+{:psql, :psql_unix, :HOST, :PORT, :USER, :PASSWORD, :DB, :SOCKET_PATH, :SOCKET_DIR}