6783902372

Committed 07 Nov 2023 11:34AM UTC coverage: 89.548% (-0.02%) from 89.571%

Build # 6783902372

Build Type

push

gh-ci

Committed by

jeroiraz

Commit Message

test(pkg/pgsql): unit testing for deallocate stmt

Signed-off-by: Jeronimo Irazabal <jeronimo.irazabal@gmail.com>

Run Details

33645 of 37572 relevant lines covered (89.55%)

146027.19 hits per line

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

93.85

/pkg/pgsql/server/session.go

/*
Copyright 2022 Codenotary Inc. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package server

import (
        "context"
        "crypto/tls"

        "net"

        "github.com/codenotary/immudb/embedded/logger"
        "github.com/codenotary/immudb/embedded/sql"
        "github.com/codenotary/immudb/pkg/client"
        "github.com/codenotary/immudb/pkg/database"
        "github.com/codenotary/immudb/pkg/pgsql/errors"
        fm "github.com/codenotary/immudb/pkg/pgsql/server/fmessages"
        "github.com/codenotary/immudb/pkg/pgsql/server/pgmeta"
)

type session struct {
        immudbHost string
        immudbPort int
        tlsConfig  *tls.Config
        log        logger.Logger

        dbList database.DatabaseList

        client client.ImmuClient

        ctx context.Context
        db  database.DB
        tx  *sql.SQLTx

        mr MessageReader

        connParams      map[string]string
        protocolVersion string

        statements map[string]*statement
        portals    map[string]*portal
}

type Session interface {
        InitializeSession() error
        HandleStartup(context.Context) error
        QueryMachine() error
        HandleError(error)
        Close() error
}

func newSession(c net.Conn, immudbHost string, immudbPort int,
        log logger.Logger, tlsConfig *tls.Config, dbList database.DatabaseList) *session {

        return &session{
                immudbHost: immudbHost,
                immudbPort: immudbPort,
                tlsConfig:  tlsConfig,
                log:        log,
                dbList:     dbList,
                mr:         NewMessageReader(c),
                statements: make(map[string]*statement),
                portals:    make(map[string]*portal),
        }
}

func (s *session) HandleError(e error) {
        pgerr := errors.MapPgError(e)

        _, err := s.writeMessage(pgerr.Encode())
        if err != nil {
                s.log.Errorf("unable to write error on wire: %w", err)
        }
}

func (s *session) nextMessage() (interface{}, bool, error) {
        msg, err := s.mr.ReadRawMessage()
        if err != nil {
                return nil, false, err
        }

        s.log.Debugf("received %s - %s message", string(msg.t), pgmeta.MTypes[msg.t])

        extQueryMode := false

        i, err := s.parseRawMessage(msg)
        if msg.t == 'P' ||
                msg.t == 'B' ||
                msg.t == 'D' ||
                msg.t == 'E' ||
                msg.t == 'H' {
                extQueryMode = true
        }

        return i, extQueryMode, err
}

func (s *session) parseRawMessage(msg *rawMessage) (interface{}, error) {
        switch msg.t {
        case 'p':
                return fm.ParsePasswordMsg(msg.payload)
        case 'Q':
                return fm.ParseQueryMsg(msg.payload)
        case 'X':
                return fm.ParseTerminateMsg(msg.payload)
        case 'P':
                return fm.ParseParseMsg(msg.payload)
        case 'B':
                return fm.ParseBindMsg(msg.payload)
        case 'D':
                return fm.ParseDescribeMsg(msg.payload)
        case 'S':
                return fm.ParseSyncMsg(msg.payload)
        case 'E':
                return fm.ParseExecuteMsg(msg.payload)
        case 'H':
                return fm.ParseFlushMsg(msg.payload)
        default:
                return nil, errors.ErrUnknowMessageType
        }
}

func (s *session) writeMessage(msg []byte) (int, error) {
        if len(msg) > 0 {
                s.log.Debugf("write %s - %s message", string(msg[0]), pgmeta.MTypes[msg[0]])
        }

        return s.mr.Write(msg)
}

1	/*
2	Copyright 2022 Codenotary Inc. All rights reserved.
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package server
18
19	import (
20	"context"
21	"crypto/tls"
22
23	"net"
24
25	"github.com/codenotary/immudb/embedded/logger"
26	"github.com/codenotary/immudb/embedded/sql"
27	"github.com/codenotary/immudb/pkg/client"
28	"github.com/codenotary/immudb/pkg/database"
29	"github.com/codenotary/immudb/pkg/pgsql/errors"
30	fm "github.com/codenotary/immudb/pkg/pgsql/server/fmessages"
31	"github.com/codenotary/immudb/pkg/pgsql/server/pgmeta"
32	)
33
34	type session struct {
35	immudbHost string
36	immudbPort int
37	tlsConfig *tls.Config
38	log logger.Logger
39
40	dbList database.DatabaseList
41
42	client client.ImmuClient
43
44	ctx context.Context
45	db database.DB
46	tx *sql.SQLTx
47
48	mr MessageReader
49
50	connParams map[string]string
51	protocolVersion string
52
53	statements map[string]*statement
54	portals map[string]*portal
55	}
56
57	type Session interface {
58	InitializeSession() error
59	HandleStartup(context.Context) error
60	QueryMachine() error
61	HandleError(error)
62	Close() error
63	}
64
65	func newSession(c net.Conn, immudbHost string, immudbPort int,
66	log logger.Logger, tlsConfig tls.Config, dbList database.DatabaseList) session {	26✔
67		26✔
68	return &session{	26✔
69	immudbHost: immudbHost,	26✔
70	immudbPort: immudbPort,	26✔
71	tlsConfig: tlsConfig,	26✔
72	log: log,	26✔
73	dbList: dbList,	26✔
74	mr: NewMessageReader(c),	26✔
75	statements: make(map[string]*statement),	26✔
76	portals: make(map[string]*portal),	26✔
77	}	26✔
78	}	26✔
79
80	func (s *session) HandleError(e error) {	25✔
81	pgerr := errors.MapPgError(e)	25✔
82		25✔
83	_, err := s.writeMessage(pgerr.Encode())	25✔
84	if err != nil {	35✔
85	s.log.Errorf("unable to write error on wire: %w", err)	10✔
86	}	10✔
87	}
88
89	func (s *session) nextMessage() (interface{}, bool, error) {	200✔
90	msg, err := s.mr.ReadRawMessage()	200✔
91	if err != nil {	221✔
92	return nil, false, err	21✔
93	}	21✔
94
95	s.log.Debugf("received %s - %s message", string(msg.t), pgmeta.MTypes[msg.t])	163✔
96		163✔
97	extQueryMode := false	163✔
98		163✔
99	i, err := s.parseRawMessage(msg)	163✔
100	if msg.t == 'P' \|\|	163✔
101	msg.t == 'B' \|\|	163✔
102	msg.t == 'D' \|\|	163✔
103	msg.t == 'E' \|\|	163✔
104	msg.t == 'H' {	232✔
105	extQueryMode = true	69✔
106	}	69✔
107
108	return i, extQueryMode, err	163✔
109	}
110
111	func (s session) parseRawMessage(msg rawMessage) (interface{}, error) {	163✔
112	switch msg.t {	163✔
113	case 'p':	23✔
114	return fm.ParsePasswordMsg(msg.payload)	23✔
115	case 'Q':	45✔
116	return fm.ParseQueryMsg(msg.payload)	45✔
117	case 'X':	7✔
118	return fm.ParseTerminateMsg(msg.payload)	7✔
119	case 'P':	22✔
120	return fm.ParseParseMsg(msg.payload)	22✔
121	case 'B':	17✔
122	return fm.ParseBindMsg(msg.payload)	17✔
123	case 'D':	19✔
124	return fm.ParseDescribeMsg(msg.payload)	19✔
125	case 'S':	19✔
126	return fm.ParseSyncMsg(msg.payload)	19✔
127	case 'E':	11✔
128	return fm.ParseExecuteMsg(msg.payload)	11✔
129	case 'H':	×
130	return fm.ParseFlushMsg(msg.payload)	×
131	default:	×
132	return nil, errors.ErrUnknowMessageType	×
133	}
134	}
135
136	func (s *session) writeMessage(msg []byte) (int, error) {	362✔
137	if len(msg) > 0 {	723✔
138	s.log.Debugf("write %s - %s message", string(msg[0]), pgmeta.MTypes[msg[0]])	361✔
139	}	361✔
140
141	return s.mr.Write(msg)	362✔
142	}

codenotary / immudb / 6783902372

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