17183634279

Committed 24 Aug 2025 03:27AM UTC coverage: 54.037% (-2.3%) from 56.309%

Build # 17183634279

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1310 from dhui/update_go

Add support for Go 1.25 and drop support for 1.23

Run Details

4377 of 8100 relevant lines covered (54.04%)

48.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/database/testing/testing.go

// Package testing has the database tests.
// All database drivers must pass the Test function.
// This lives in it's own package so it stays a test dependency.
package testing

import (
        "bytes"
        "errors"
        "fmt"
        "io"
        "testing"
        "time"

        "github.com/golang-migrate/migrate/v4/database"
)

// Test runs tests against database implementations.
func Test(t *testing.T, d database.Driver, migration []byte) {
        if migration == nil {
                t.Fatal("test must provide migration reader")
        }

        TestNilVersion(t, d) // test first
        TestLockAndUnlock(t, d)
        TestRun(t, d, bytes.NewReader(migration))
        TestSetVersion(t, d) // also tests Version()
        // Drop breaks the driver, so test it last.
        TestDrop(t, d)
}

func TestNilVersion(t *testing.T, d database.Driver) {
        v, _, err := d.Version()
        if err != nil {
                t.Fatal(err)
        }
        if v != database.NilVersion {
                t.Fatalf("Version: expected version to be NilVersion (-1), got %v", v)
        }
}

func TestLockAndUnlock(t *testing.T, d database.Driver) {
        // add a timeout, in case there is a deadlock
        done := make(chan struct{})
        errs := make(chan error)

        go func() {
                timeout := time.After(15 * time.Second)
                for {
                        select {
                        case <-done:
                                return
                        case <-timeout:
                                errs <- fmt.Errorf("Timeout after 15 seconds. Looks like a deadlock in Lock/UnLock.\n%#v", d)
                                return
                        }
                }
        }()

        // run the locking test ...
        go func() {
                if err := d.Lock(); err != nil {
                        errs <- err
                        return
                }

                // try to acquire lock again
                if err := d.Lock(); err == nil {
                        errs <- errors.New("lock: expected err not to be nil")
                        return
                }

                // unlock
                if err := d.Unlock(); err != nil {
                        errs <- err
                        return
                }

                // try to lock
                if err := d.Lock(); err != nil {
                        errs <- err
                        return
                }
                if err := d.Unlock(); err != nil {
                        errs <- err
                        return
                }
                // notify everyone
                close(done)
        }()

        // wait for done or any error
        for {
                select {
                case <-done:
                        return
                case err := <-errs:
                        t.Fatal(err)
                }
        }
}

func TestRun(t *testing.T, d database.Driver, migration io.Reader) {
        if migration == nil {
                t.Fatal("migration can't be nil")
        }

        if err := d.Run(migration); err != nil {
                t.Fatal(err)
        }
}

func TestDrop(t *testing.T, d database.Driver) {
        if err := d.Drop(); err != nil {
                t.Fatal(err)
        }
}

func TestSetVersion(t *testing.T, d database.Driver) {
        // nolint:maligned
        testCases := []struct {
                name            string
                version         int
                dirty           bool
                expectedErr     error
                expectedReadErr error
                expectedVersion int
                expectedDirty   bool
        }{
                {name: "set 1 dirty", version: 1, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: 1, expectedDirty: true},
                {name: "re-set 1 dirty", version: 1, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: 1, expectedDirty: true},
                {name: "set 2 clean", version: 2, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: 2, expectedDirty: false},
                {name: "re-set 2 clean", version: 2, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: 2, expectedDirty: false},
                {name: "last migration dirty", version: database.NilVersion, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: database.NilVersion, expectedDirty: true},
                {name: "last migration clean", version: database.NilVersion, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: database.NilVersion, expectedDirty: false},
        }

        for _, tc := range testCases {
                t.Run(tc.name, func(t *testing.T) {
                        err := d.SetVersion(tc.version, tc.dirty)
                        if err != tc.expectedErr {
                                t.Fatal("Got unexpected error:", err, "!=", tc.expectedErr)
                        }
                        v, dirty, readErr := d.Version()
                        if readErr != tc.expectedReadErr {
                                t.Fatal("Got unexpected error:", readErr, "!=", tc.expectedReadErr)
                        }
                        if v != tc.expectedVersion {
                                t.Error("Got unexpected version:", v, "!=", tc.expectedVersion)
                        }
                        if dirty != tc.expectedDirty {
                                t.Error("Got unexpected dirty value:", dirty, "!=", tc.dirty)
                        }
                })
        }
}

1	// Package testing has the database tests.
2	// All database drivers must pass the Test function.
3	// This lives in it's own package so it stays a test dependency.
4	package testing
5
6	import (
7	"bytes"
8	"errors"
9	"fmt"
10	"io"
11	"testing"
12	"time"
13
14	"github.com/golang-migrate/migrate/v4/database"
15	)
16
17	// Test runs tests against database implementations.
18	func Test(t *testing.T, d database.Driver, migration []byte) {	×
19	if migration == nil {	×
20	t.Fatal("test must provide migration reader")	×
21	}	×
22
23	TestNilVersion(t, d) // test first	×
24	TestLockAndUnlock(t, d)	×
25	TestRun(t, d, bytes.NewReader(migration))	×
26	TestSetVersion(t, d) // also tests Version()	×
27	// Drop breaks the driver, so test it last.	×
28	TestDrop(t, d)	×
29	}
30
31	func TestNilVersion(t *testing.T, d database.Driver) {	×
32	v, _, err := d.Version()	×
33	if err != nil {	×
34	t.Fatal(err)	×
35	}	×
36	if v != database.NilVersion {	×
37	t.Fatalf("Version: expected version to be NilVersion (-1), got %v", v)	×
38	}	×
39	}
40
41	func TestLockAndUnlock(t *testing.T, d database.Driver) {	×
42	// add a timeout, in case there is a deadlock	×
43	done := make(chan struct{})	×
44	errs := make(chan error)	×
45		×
46	go func() {	×
47	timeout := time.After(15 * time.Second)	×
48	for {	×
49	select {	×
50	case <-done:	×
51	return	×
52	case <-timeout:	×
53	errs <- fmt.Errorf("Timeout after 15 seconds. Looks like a deadlock in Lock/UnLock.\n%#v", d)	×
54	return	×
55	}
56	}
57	}()
58
59	// run the locking test ...
60	go func() {	×
61	if err := d.Lock(); err != nil {	×
62	errs <- err	×
63	return	×
64	}	×
65
66	// try to acquire lock again
67	if err := d.Lock(); err == nil {	×
68	errs <- errors.New("lock: expected err not to be nil")	×
69	return	×
70	}	×
71
72	// unlock
73	if err := d.Unlock(); err != nil {	×
74	errs <- err	×
75	return	×
76	}	×
77
78	// try to lock
79	if err := d.Lock(); err != nil {	×
80	errs <- err	×
81	return	×
82	}	×
83	if err := d.Unlock(); err != nil {	×
84	errs <- err	×
85	return	×
86	}	×
87	// notify everyone
88	close(done)	×
89	}()
90
91	// wait for done or any error
92	for {	×
93	select {	×
94	case <-done:	×
95	return	×
96	case err := <-errs:	×
97	t.Fatal(err)	×
98	}
99	}
100	}
101
102	func TestRun(t *testing.T, d database.Driver, migration io.Reader) {	×
103	if migration == nil {	×
104	t.Fatal("migration can't be nil")	×
105	}	×
106
107	if err := d.Run(migration); err != nil {	×
108	t.Fatal(err)	×
109	}	×
110	}
111
112	func TestDrop(t *testing.T, d database.Driver) {	×
113	if err := d.Drop(); err != nil {	×
114	t.Fatal(err)	×
115	}	×
116	}
117
118	func TestSetVersion(t *testing.T, d database.Driver) {	×
119	// nolint:maligned	×
120	testCases := []struct {	×
121	name string	×
122	version int	×
123	dirty bool	×
124	expectedErr error	×
125	expectedReadErr error	×
126	expectedVersion int	×
127	expectedDirty bool	×
128	}{	×
129	{name: "set 1 dirty", version: 1, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: 1, expectedDirty: true},	×
130	{name: "re-set 1 dirty", version: 1, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: 1, expectedDirty: true},	×
131	{name: "set 2 clean", version: 2, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: 2, expectedDirty: false},	×
132	{name: "re-set 2 clean", version: 2, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: 2, expectedDirty: false},	×
133	{name: "last migration dirty", version: database.NilVersion, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: database.NilVersion, expectedDirty: true},	×
134	{name: "last migration clean", version: database.NilVersion, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: database.NilVersion, expectedDirty: false},	×
135	}	×
136		×
137	for _, tc := range testCases {	×
138	t.Run(tc.name, func(t *testing.T) {	×
139	err := d.SetVersion(tc.version, tc.dirty)	×
140	if err != tc.expectedErr {	×
141	t.Fatal("Got unexpected error:", err, "!=", tc.expectedErr)	×
142	}	×
143	v, dirty, readErr := d.Version()	×
144	if readErr != tc.expectedReadErr {	×
145	t.Fatal("Got unexpected error:", readErr, "!=", tc.expectedReadErr)	×
146	}	×
147	if v != tc.expectedVersion {	×
148	t.Error("Got unexpected version:", v, "!=", tc.expectedVersion)	×
149	}	×
150	if dirty != tc.expectedDirty {	×
151	t.Error("Got unexpected dirty value:", dirty, "!=", tc.dirty)	×
152	}	×
153	})
154	}
155	}

golang-migrate / migrate / 17183634279

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous