feat: Enable CI for Redis CE 8.0

.github/actions/run-tests/action.yml

@@ -21,12 +21,7 @@ runs:
         CLIENT_LIBS_TEST_IMAGE: "redislabs/client-libs-test:${{ inputs.redis-version }}"
       run: |
         set -e
-        redis_major_version=$(echo "$REDIS_VERSION" | grep -oP '^\d+')
-        if (( redis_major_version < 8 )); then
-          echo "Using redis-stack for module tests"
-        else
-          echo "Using redis CE for module tests"
-        fi        
+        redis_version_np=$(echo "$REDIS_VERSION" | grep -oP '^\d+.\d+')
 
         # Mapping of redis version to redis testing containers
         declare -A redis_version_mapping=(
@@ -36,27 +31,23 @@ runs:
         )
 
         if [[ -v redis_version_mapping[$REDIS_VERSION] ]]; then
-          echo "REDIS_MAJOR_VERSION=${redis_major_version}" >> $GITHUB_ENV
+          echo "REDIS_VERSION=${redis_version_np}" >> $GITHUB_ENV
           echo "REDIS_IMAGE=redis:${{ inputs.redis-version }}" >> $GITHUB_ENV
           echo "CLIENT_LIBS_TEST_IMAGE=redislabs/client-libs-test:${redis_version_mapping[$REDIS_VERSION]}" >> $GITHUB_ENV
         else
           echo "Version not found in the mapping."
           exit 1
         fi
-        sleep 10 # time to settle
+        sleep 10 # wait for redis to start
       shell: bash
     - name: Set up Docker Compose environment with redis ${{ inputs.redis-version }}
-      run: docker compose --profile all up -d
+      run: |
+        make docker.start
       shell: bash
     - name: Run tests
       env:
         RCE_DOCKER: "true"
         RE_CLUSTER: "false"
       run: |
-        go test \
-        --ginkgo.skip-file="ring_test.go" \
-        --ginkgo.skip-file="sentinel_test.go" \
-        --ginkgo.skip-file="pubsub_test.go" \
-        --ginkgo.skip-file="gears_commands_test.go" \
-        --ginkgo.label-filter="!NonRedisEnterprise"
+        make test.ci
       shell: bash

.github/workflows/build.yml

@@ -10,13 +10,19 @@ permissions:
   contents: read
 
 jobs:
-  build:
-    name: build
+
+  benchmark:
+    name: benchmark
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        go-version: [1.21.x, 1.22.x, 1.23.x]
+        redis-version:
+          - "8.0-M03" # 8.0 milestone 4
+          - "7.4.2" # should use redis stack 7.4
+        go-version:
+          - "1.23.x"
+          - "1.24.x"
 
     steps:
       - name: Set up ${{ matrix.go-version }}
@@ -27,15 +33,38 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Test
-        run: make test
+      - name: Setup Test environment
+        env:
+          REDIS_VERSION: ${{ matrix.redis-version }}
+          CLIENT_LIBS_TEST_IMAGE: "redislabs/client-libs-test:${{ matrix.redis-version }}"
+        run: |
+          set -e
+          redis_version_np=$(echo "$REDIS_VERSION" | grep -oP '^\d+.\d+')
+
+          # Mapping of redis version to redis testing containers
+          declare -A redis_version_mapping=(
+            ["8.0-M03"]="8.0-M04-pre"
+            ["7.4.2"]="rs-7.4.0-v2"
+          )
+          if [[ -v redis_version_mapping[$REDIS_VERSION] ]]; then
+            echo "REDIS_VERSION=${redis_version_np}" >> $GITHUB_ENV
+            echo "REDIS_IMAGE=redis:${{ matrix.redis-version }}" >> $GITHUB_ENV
+            echo "CLIENT_LIBS_TEST_IMAGE=redislabs/client-libs-test:${redis_version_mapping[$REDIS_VERSION]}" >> $GITHUB_ENV
+          else
+            echo "Version not found in the mapping."
+            exit 1
+          fi
+        shell: bash
+      - name: Set up Docker Compose environment with redis ${{ matrix.redis-version }}
+        run: make docker.start
+        shell: bash
+      - name: Benchmark Tests
+        env:
+          RCE_DOCKER: "true"
+          RE_CLUSTER: "false"
+        run: make bench
+        shell: bash
 
-      - name: Upload to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          files: coverage.txt
-          token: ${{ secrets.CODECOV_TOKEN }}
-
   test-redis-ce:
     name: test-redis-ce
     runs-on: ubuntu-latest
@@ -47,11 +76,10 @@ jobs:
             - "7.4.2" # should use redis stack 7.4
             - "7.2.7" # should redis stack 7.2
           go-version:
-            - "1.22.x"
             - "1.23.x"
+            - "1.24.x"
 
     steps:
-
       - name: Checkout code
         uses: actions/checkout@v4
 
@@ -60,4 +88,10 @@ jobs:
         with:
           go-version: ${{matrix.go-version}}
           redis-version: ${{ matrix.redis-version }}
-
+
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          files: coverage.txt
+          token: ${{ secrets.CODECOV_TOKEN }}
+

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,68 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

.github/workflows/doctests.yaml

@@ -25,7 +25,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go-version: [ "1.21", "1.22", "1.23" ]
+        go-version: ["1.24"]
 
     steps:
       - name: Set up ${{ matrix.go-version }}
@@ -38,4 +38,4 @@ jobs:
 
       - name: Test doc examples
         working-directory: ./doctests
-        run: go test
+        run: go test -v

.github/workflows/test-redis-enterprise.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go-version: [1.23.x]
+        go-version: [1.24.x]
         re-build: ["7.4.2-54"]
 
     steps:
@@ -47,7 +47,7 @@ jobs:
       - name: Test
         env:
           RE_CLUSTER: true
-          REDIS_MAJOR_VERSION: 7
+          REDIS_VERSION: "7.4"
         run: |
           go test \
           --ginkgo.skip-file="ring_test.go" \

.gitignore

@@ -5,4 +5,6 @@ testdata/*
 *.tar.gz
 *.dic
 redis8tests.sh
-.vscode
+coverage.txt
+**/coverage.txt
+.vscode

CONTRIBUTING.md

@@ -32,20 +32,33 @@ Here's how to get started with your code contribution:
 
 1.  Create your own fork of go-redis
 2.  Do the changes in your fork
-3.  If you need a development environment, run `make test`. Note: this clones and builds the latest release of [redis](https://redis.io). You also need a redis-stack-server docker, in order to run the capabilities tests. This can be started by running:
-    ```docker run -p 6379:6379 -it redis/redis-stack-server:edge```
-4.  While developing, make sure the tests pass by running `make tests`
+3.  If you need a development environment, run `make docker.start`.
+
+> Note: this clones and builds the docker containers specified in `docker-compose.yml`, to understand more about
+> the infrastructure that will be started you can check the `docker-compose.yml`. You also have the possiblity
+> to specify the redis image that will be pulled with the env variable `CLIENT_LIBS_TEST_IMAGE`.
+> By default the docker image that will be pulled and started is `redislabs/client-libs-test:rs-7.4.0-v2`.
+> If you want to test with newer Redis version, using a newer version of `redislabs/client-libs-test` should work out of the box.
+
+4.  While developing, make sure the tests pass by running `make test` (if you have the docker containers running, `make test.ci` may be sufficient).
+> Note: `make test` will try to start all containers, run the tests with `make test.ci` and then stop all containers.
 5.  If you like the change and think the project could use it, send a
     pull request
 
 To see what else is part of the automation, run `invoke -l`
 
+
 ## Testing
 
-Call `make test` to run all tests, including linters.
+### Setting up Docker
+To run the tests, you need to have Docker installed and running. If you are using a host OS that does not support
+docker host networks out of the box (e.g. Windows, OSX), you need to set up a docker desktop and enable docker host networks.
+
+### Running tests
+Call `make test` to run all tests.
 
 Continuous Integration uses these same wrappers to run all of these
-tests against multiple versions of python. Feel free to test your
+tests against multiple versions of redis. Feel free to test your
 changes against all the go versions supported, as declared by the
 [build.yml](./.github/workflows/build.yml) file.
 

Makefile

@@ -1,45 +1,35 @@
 GO_MOD_DIRS := $(shell find . -type f -name 'go.mod' -exec dirname {} \; | sort)
-export REDIS_MAJOR_VERSION := 7
 
-test: testdeps
-	docker start go-redis-redis-stack || docker run -d --name go-redis-redis-stack  -p 6379:6379 -e REDIS_ARGS="--enable-debug-command yes --enable-module-command yes" redis/redis-stack-server:latest
-	$(eval GO_VERSION := $(shell go version | cut -d " " -f 3 | cut -d. -f2))
+docker.start:
+	docker compose --profile all up -d --quiet-pull
+
+docker.stop:
+	docker compose --profile all down
+
+test:
+	$(MAKE) docker.start
+	$(MAKE) test.ci
+	$(MAKE) docker.stop
+
+test.ci:
 	set -e; for dir in $(GO_MOD_DIRS); do \
-	  if echo "$${dir}" | grep -q "./example" && [ "$(GO_VERSION)" = "19" ]; then \
-	    echo "Skipping go test in $${dir} due to Go version 1.19 and dir contains ./example"; \
-	    continue; \
-	  fi; \
 	  echo "go test in $${dir}"; \
 	  (cd "$${dir}" && \
 	    go mod tidy -compat=1.18 && \
-	    go test && \
-	    go test ./... -short -race && \
-	    go test ./... -run=NONE -bench=. -benchmem && \
-	    env GOOS=linux GOARCH=386 go test && \
-	    go test -coverprofile=coverage.txt -covermode=atomic ./... && \
-	    go vet); \
+	    go vet && \
+	    go test -coverprofile=coverage.txt -covermode=atomic ./... -race); \
 	done
 	cd internal/customvet && go build .
 	go vet -vettool ./internal/customvet/customvet
-	docker stop go-redis-redis-stack
 
-testdeps: testdata/redis/src/redis-server
-
-bench: testdeps
+bench:
 	go test ./... -test.run=NONE -test.bench=. -test.benchmem
 
-.PHONY: all test testdeps bench fmt
+.PHONY: all test bench fmt
 
 build:
 	go build .
 
-testdata/redis:
-	mkdir -p $@
-	wget -qO- https://download.redis.io/releases/redis-7.4.2.tar.gz  | tar xvz --strip-components=1 -C $@
-
-testdata/redis/src/redis-server: testdata/redis
-	cd $< && make all
-
 fmt:
 	gofumpt -w ./
 	goimports -w  -local github.com/redis/go-redis ./

README.md

@@ -14,6 +14,20 @@
 > See [OpenTelemetry](https://github.com/redis/go-redis/tree/master/example/otel) example which
 > demonstrates how you can use Uptrace to monitor go-redis.
 
+## Supported versions
+
+In `go-redis` we are aiming to support the last three releases of Redis. Currently, this means we do support:
+- [Redis 7.2](https://raw.githubusercontent.com/redis/redis/7.2/00-RELEASENOTES) - using Redis Stack 7.2 for modules support
+- [Redis 7.4](https://raw.githubusercontent.com/redis/redis/7.4/00-RELEASENOTES) - using Redis Stack 7.4 for modules support
+- [Redis 8.0](https://raw.githubusercontent.com/redis/redis/8.0/00-RELEASENOTES) - using Redis CE 8.0 where modules are included
+
+Although the `go.mod` states it requires at minimum `go 1.18`, our CI is configured to run the tests against all three
+versions of Redis and latest two versions of Go ([1.23](https://go.dev/doc/devel/release#go1.23.0),
+[1.24](https://go.dev/doc/devel/release#go1.24.0)). We observe that some modules related test may not pass with
+Redis Stack 7.2 and some commands are changed with Redis CE 8.0.
+Please do refer to the documentation and the tests if you experience any issues. We do plan to update the go version
+in the `go.mod` to `go 1.24` in one of the next releases.
+
 ## How do I Redis?
 
 [Learn for free at Redis University](https://university.redis.com/)