ci: Stop relying on Travis' version of PostgreSQL

We now install the necessary version of PostgreSQL explicitly.  This
allows testing on PostgreSQL versions that are not supported by Travis
directly.

And also, do an explicit check that the version of the server being
tested corresponds to the PGVERSION environment variable.

Author: elprans

.ci/travis-before-install.sh

@@ -1,5 +1,12 @@
 #!/bin/bash
 
+set -e -x
+
+if [ -z "${PGVERSION}" ]; then
+    echo "Missing PGVERSION environment variable."
+    exit 1
+fi
+
 if [[ "${TRAVIS_OS_NAME}" == "linux" && "${BUILD}" == *wheels* ]]; then
     # Allow docker guests to connect to the database
     sudo service postgresql stop ${PGVERSION}
@@ -9,3 +16,24 @@ if [[ "${TRAVIS_OS_NAME}" == "linux" && "${BUILD}" == *wheels* ]]; then
         sudo tee --append /etc/postgresql/${PGVERSION}/main/pg_hba.conf
     sudo service postgresql start ${PGVERSION}
 fi
+
+if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
+    git clone --depth 1 https://github.com/yyuu/pyenv.git ~/.pyenv
+    PYENV_ROOT="$HOME/.pyenv"
+    PATH="$PYENV_ROOT/bin:$PATH"
+    eval "$(pyenv init -)"
+
+    if ! (pyenv versions | grep "${PYTHON_VERSION}$"); then
+        pyenv install ${PYTHON_VERSION}
+    fi
+    pyenv global ${PYTHON_VERSION}
+    pyenv rehash
+
+    # Install PostgreSQL
+    brew update >/dev/null
+    if brew ls --versions postgresql@${PGVERSION} > /dev/null; then
+        brew upgrade postgresql@${PGVERSION}
+    else
+        brew install postgresql@${PGVERSION}
+    fi
+fi

.ci/travis-build-wheels.sh

@@ -13,7 +13,6 @@ if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
     PYENV_ROOT="$HOME/.pyenv"
     PATH="$PYENV_ROOT/bin:$PATH"
     eval "$(pyenv init -)"
-    pyenv local ${PYTHON_VERSION}
 fi
 
 PACKAGE_VERSION=$(python ".ci/package-version.py")

.ci/travis-install.sh

@@ -3,16 +3,9 @@
 set -e -x
 
 if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
-    git clone --depth 1 https://github.com/yyuu/pyenv.git ~/.pyenv
     PYENV_ROOT="$HOME/.pyenv"
     PATH="$PYENV_ROOT/bin:$PATH"
     eval "$(pyenv init -)"
-
-    if ! (pyenv versions | grep "${PYTHON_VERSION}$"); then
-        pyenv install ${PYTHON_VERSION}
-    fi
-    pyenv global ${PYTHON_VERSION}
-    pyenv rehash
 fi
 
 pip install --upgrade pip wheel

.ci/travis-tests.sh

@@ -13,6 +13,13 @@ if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
     eval "$(pyenv init -)"
 fi
 
+# Make sure we test with the correct PostgreSQL version.
+if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
+    export PGINSTALLATION="/usr/local/opt/postgresql@${PGVERSION}/bin"
+else
+    export PGINSTALLATION="/usr/lib/postgresql/${PGVERSION}/bin"
+fi
+
 if [[ "${BUILD}" == *quicktests* ]]; then
     make && make quicktest
 else

.travis.yml

@@ -18,6 +18,12 @@ env:
 
         - DOCS_PUSH_KEY_LABEL=0760b951e99c
 
+addons:
+    apt:
+        sources:
+            - sourceline: 'deb https://apt.postgresql.org/pub/repos/apt/ trusty-pgdg main'
+              key_url: 'https://www.postgresql.org/media/keys/ACCC4CF8.asc'
+
 branches:
     # Avoid building PR branches.
     only:
@@ -27,57 +33,47 @@ branches:
         - /^v\d+(\.\d+)*$/
 
 matrix:
-    fast_finish: true
+    fast_finish:
+        true
 
     include:
-        - os: osx
-          env: BUILD=tests,wheels PYTHON_VERSION=3.5.2 PIP_USER=1
-
-        - os: osx
-          osx_image: xcode8.3
-          env: BUILD=tests,wheels PYTHON_VERSION=3.6.0 PIP_USER=1
-
         # Do quick test runs for each supported version of PostgreSQL
         # minus the latest.
         - os: linux
           dist: trusty
           sudo: false
           language: python
           python: "3.5"
-          services: postgresql
           env: BUILD=quicktests PGVERSION=9.2
           addons:
-              postgresql: '9.2'
+              apt: {packages: [postgresql-9.2]}
 
         - os: linux
           dist: trusty
           sudo: false
           language: python
           python: "3.5"
-          services: postgresql
           env: BUILD=quicktests PGVERSION=9.3
           addons:
-              postgresql: '9.3'
+              apt: {packages: [postgresql-9.3]}
 
         - os: linux
           dist: trusty
           sudo: false
           language: python
           python: "3.5"
-          services: postgresql
           env: BUILD=quicktests PGVERSION=9.4
           addons:
-              postgresql: '9.4'
+              apt: {packages: [postgresql-9.4]}
 
         - os: linux
           dist: trusty
           sudo: false
           language: python
           python: "3.5"
-          services: postgresql
           env: BUILD=quicktests PGVERSION=9.5
           addons:
-              postgresql: '9.5'
+              apt: {packages: [postgresql-9.5]}
 
         # Do a full test run on the latest supported version of PostgreSQL
         # on each supported version of Python.
@@ -86,30 +82,27 @@ matrix:
           sudo: false
           language: python
           python: "3.5"
-          services: postgresql
           env: BUILD=tests PGVERSION=9.6
           addons:
-              postgresql: '9.6'
+              apt: {packages: [postgresql-9.6]}
 
         - os: linux
           dist: trusty
           sudo: false
           language: python
           python: "3.6"
-          services: postgresql
           env: BUILD=tests PGVERSION=9.6
           addons:
-              postgresql: '9.6'
+              apt: {packages: [postgresql-9.6]}
 
         - os: linux
           dist: trusty
           sudo: false
           language: python
           python: "3.7-dev"
-          services: postgresql
           env: BUILD=tests PGVERSION=9.6
           addons:
-              postgresql: '9.6'
+              apt: {packages: [postgresql-9.6]}
 
         # Build manylinux wheels.  Each wheel will be tested,
         # so there is no need for BUILD=tests here.
@@ -121,9 +114,16 @@ matrix:
           language: python
           python: "3.5"
           env: BUILD=wheels,docs,release PGVERSION=9.6
-          services: [postgresql, docker]
+          services: [docker]
           addons:
-              postgresql: '9.6'
+              apt: {packages: [postgresql-9.6]}
+
+        - os: osx
+          env: BUILD=tests,wheels PYTHON_VERSION=3.5.2 PIP_USER=1 PGVERSION=9.6
+
+        - os: osx
+          osx_image: xcode8.3
+          env: BUILD=tests,wheels PYTHON_VERSION=3.6.1 PIP_USER=1 PGVERSION=9.6
 
     allow_failures:
         - python: "3.7-dev"

asyncpg/cluster.py

@@ -84,8 +84,7 @@ class Cluster:
     def __init__(self, data_dir, *, pg_config_path=None):
         self._data_dir = data_dir
         self._pg_config_path = pg_config_path
-        self._pg_config = None
-        self._pg_config_data = None
+        self._pg_bin_dir = os.environ.get('PGINSTALLATION')
         self._pg_ctl = None
         self._daemon_pid = None
         self._daemon_process = None
@@ -374,11 +373,18 @@ def trust_local_replication_by(self, user):
             self.reload()
 
     def _init_env(self):
-        self._pg_config = self._find_pg_config(self._pg_config_path)
-        self._pg_config_data = self._run_pg_config(self._pg_config)
-        self._pg_version = self._get_pg_version()
+        if not self._pg_bin_dir:
+            pg_config = self._find_pg_config(self._pg_config_path)
+            pg_config_data = self._run_pg_config(pg_config)
+
+            self._pg_bin_dir = pg_config_data.get('bindir')
+            if not self._pg_bin_dir:
+                raise ClusterError(
+                    'pg_config output did not provide the BINDIR value')
+
         self._pg_ctl = self._find_pg_binary('pg_ctl')
         self._postgres = self._find_pg_binary('postgres')
+        self._pg_version = self._get_pg_version()
 
     def _connection_addr_from_pidfile(self):
         pidfile = os.path.join(self._data_dir, 'postmaster.pid')
@@ -505,13 +511,7 @@ def _find_pg_config(self, pg_config_path):
         return pg_config_path
 
     def _find_pg_binary(self, binary):
-        bindir = self._pg_config_data.get('bindir')
-        if not bindir:
-            raise ClusterError(
-                'could not find {} executable: '.format(binary) +
-                'pg_config output did not provide the BINDIR value')
-
-        bpath = platform_exe(os.path.join(bindir, binary))
+        bpath = platform_exe(os.path.join(self._pg_bin_dir, binary))
 
         if not os.path.isfile(bpath):
             raise ClusterError(
@@ -521,9 +521,23 @@ def _find_pg_binary(self, binary):
         return bpath
 
     def _get_pg_version(self):
-        version_string = self._pg_config_data.get('version')
-        if not version_string:
-            raise ClusterError('could not determine PostgreSQL version')
+        process = subprocess.run(
+            [self._postgres, '--version'],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        stdout, stderr = process.stdout, process.stderr
+
+        if process.returncode != 0:
+            raise ClusterError(
+                'postgres --version exited with status {:d}: {}'.format(
+                    process.returncode, stderr))
+
+        version_string = stdout.decode('utf-8').strip(' \n')
+        prefix = 'postgres (PostgreSQL) '
+        if not version_string.startswith(prefix):
+            raise ClusterError(
+                'could not determine server version from {!r}'.format(
+                    version_string))
+        version_string = version_string[len(prefix):]
 
         return serverversion.split_server_version_string(version_string)
 

tests/test__environment.py

@@ -0,0 +1,29 @@
+# Copyright (C) 2016-present the asyncpg authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of asyncpg and is released under
+# the Apache 2.0 License: http://www.apache.org/licenses/LICENSE-2.0
+
+
+import os
+import unittest
+
+import asyncpg
+import asyncpg.serverversion
+
+from asyncpg import _testbase as tb
+
+
+class TestEnvironment(tb.ConnectedTestCase):
+    @unittest.skipIf(not os.environ.get('PGVERSION'),
+                     "environ[PGVERSION] is not set")
+    async def test_environment_server_version(self):
+        pgver = os.environ.get('PGVERSION')
+        env_ver = asyncpg.serverversion.split_server_version_string(pgver)
+        srv_ver = self.con.get_server_version()
+
+        self.assertEqual(
+            env_ver[:2], srv_ver[:2],
+            'Expecting PostgreSQL version {pgver}, got {maj}.{min}.'.format(
+                pgver=pgver, maj=srv_ver.major, min=srv_ver.minor)
+        )