fbintf/testsuite/Test16.pas

(*
 *  Firebird Interface (fbintf) Test suite. This program is used to
 *  test the Firebird Pascal Interface and provide a semi-automated
 *  pass/fail check for each test.
 *
 *  The contents of this file are subject to the Initial Developer's
 *  Public License Version 1.0 (the "License"); you may not use this
 *  file except in compliance with the License. You may obtain a copy
 *  of the License here:
 *
 *    http://www.firebirdsql.org/index.php?op=doc&id=idpl
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing rights
 *  and limitations under the License.
 *
 *  The Initial Developer of the Original Code is Tony Whyman.
 *
 *  The Original Code is (C) 2016 Tony Whyman, MWA Software
 *  (http://www.mwasoftware.co.uk).
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): ______________________________________.
 *
*)

unit Test16;
{$IFDEF MSWINDOWS} 
{$DEFINE WINDOWS} 
{$ENDIF}

{$IFDEF FPC}
{$mode delphi}
{$codepage UTF8}
{$ENDIF}

{Test 16: Error handling}

{ This test tests for correct responses to various error conditions:

  - Malformed database name.
  - Invalid User Name
  - Invalid password
  - Invalid Update SQL Statement
  - Invalid Select SQL
  - Transaction not started
  - Invalid parameter by name when should be positional
  - Invalid server name
  - invalid user name - logon to server
  - invalid password
}

interface

uses
  Classes, SysUtils, TestApplication, FBTestApp, IB;

type

  { TTest16 }

  TTest16 = class(TFBTestBase)
  private
    procedure DBTests(CharSet: AnsiString; SQLDialect: integer);
    procedure ServiceTests(CharSet: AnsiString; SQLDialect: integer);
  public
    function TestTitle: AnsiString; override;
    procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
  end;


implementation

{ TTest16 }

procedure TTest16.DBTests(CharSet: AnsiString; SQLDialect: integer);
var DPB: IDPB;
    Attachment: IAttachment;
    Transaction: ITransaction;
    Statement: IStatement;
begin
  DPB := FirebirdAPI.AllocateDPB;
  DPB.Add(isc_dpb_user_name).setAsString(Owner.GetUserName);
  DPB.Add(isc_dpb_password).setAsString(Owner.GetPassword);
  DPB.Add(isc_dpb_lc_ctype).setAsString('UTF8');
  try
    writeln(OutFile,'Invalid Database Name Test');
    Attachment := FirebirdAPI.OpenDatabase('localhost:Malformed Name',DPB);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  DPB.Find(isc_dpb_user_name).setAsString('Captain Nemo');
  try
    writeln(OutFile,'Invalid User Name Test');
    Attachment := FirebirdAPI.OpenDatabase(Owner.GetEmployeeDatabaseName,DPB);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  DPB.Find(isc_dpb_user_name).setAsString(Owner.GetUserName);
  DPB.Find(isc_dpb_password).setAsString('not a pwd');
  try
    writeln(OutFile,'Invalid password Test');
    Attachment := FirebirdAPI.OpenDatabase(Owner.GetEmployeeDatabaseName,DPB);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  DPB.Find(isc_dpb_password).setAsString(Owner.GetPassword);
  Attachment := FirebirdAPI.OpenDatabase(Owner.GetEmployeeDatabaseName,DPB);
  Transaction := Attachment.StartTransaction([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],taRollback);
  try
    writeln(OutFile,'Invalid Prepare SQL Test');
    Statement := Attachment.Prepare(Transaction,'Update Employee Set Unknown_Date = ? Where EMP_NO = ?',3);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  try
    writeln(OutFile,'Invalid Open Cursor SQL Test');
    Attachment.OpenCursorAtStart(Transaction,
           'Select X,count(*) As Counter from EMPLOYEE',3);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  Transaction.Rollback;
  try
    writeln(OutFile,'Transaction not started Test');
    Attachment.OpenCursorAtStart(Transaction,
           'Select count(*) As Counter from EMPLOYEE',3);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  Transaction.Start;
  try
    writeln(OutFile,'Invalid Param SQL Type Test');
    Statement := Attachment.Prepare(Transaction,'Update Employee Set Hire_Date = ? Where EMP_NO = ?',3);
    Statement.SQLParams.ByName('EMP_NO').AsDate := EncodeDate(2016,11,5);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  Transaction.Rollback;
  Transaction.Start;
  try
    writeln(OutFile,'Case sensitive Param SQL  Test');
    Statement := Attachment.PrepareWithNamedParameters(Transaction,'Update Employee Set Hire_Date = :Hire_Date Where emp_no = :emp_no',3,false,true);
    Statement.SQLParams.ByName('Hire_Date').AsDate := EncodeDate(2016,11,5);
    Statement.SQLParams.ByName('emp_no').AsInteger := 1;
    Statement.SQLParams.ByName('EMP_NO').AsInteger := 1;
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  Transaction.Rollback;
  Transaction.Start;
  writeln(Outfile,'Stale Reference Check');
  writeln(Outfile,'First test correct usage');
  Statement :=  Attachment.Prepare(Transaction,'Select count(*) As Counter from EMPLOYEE Where Hire_Date < ?',3);
  Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
  ReportResults(Statement);
  try
    writeln(Outfile,'New Transaction before param set');
    Statement.Prepare(Transaction);
    Transaction.Rollback;
    Transaction.Start;
    Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
    ReportResults(Statement);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  Transaction.Rollback;
  Transaction.Start;
  try
    writeln(Outfile,'New Transaction before Open Cursor');
    Statement.Prepare(Transaction);
    Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
    Transaction.Rollback;
    Transaction.Start;
    ReportResults(Statement);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  Transaction.Rollback;
  Transaction.Start;
  writeln(Outfile,'Stop Stale Reference Checks');
  Statement.SetStaleReferenceChecks(false);
  try
    writeln(Outfile,'New Transaction before param set');
    Statement.Prepare(Transaction);
    Transaction.Rollback;
    Transaction.Start;
    Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
    ReportResults(Statement);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  try
    writeln(Outfile,'New Transaction before Open Cursor');
    Statement.Prepare(Transaction);
    Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
    Transaction.Rollback;
    Transaction.Start;
    ReportResults(Statement);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
end;

procedure TTest16.ServiceTests(CharSet: AnsiString; SQLDialect: integer);
var SPB: ISPB;
    Service: IServiceManager;
    ServerName: AnsiString;
    DBName: AnsiString;
begin
  if not FirebirdAPI.HasServiceAPI then Exit;

  DBName := ExtractDBName(Owner.GetEmployeeDatabaseName);
  ServerName := Owner.Server;

  SPB := FirebirdAPI.AllocateSPB;
  SPB.Add(isc_spb_user_name).setAsString(Owner.GetUserName);
  SPB.Add(isc_spb_password).setAsString(Owner.GetPassword);
  try
    writeln(OutFile,'Invalid Server Name Test');
    Service := FirebirdAPI.GetServiceManager('unknown',TCP,SPB);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;

  SPB.Find(isc_spb_user_name).setAsString('Captain Nemo');
  try
    writeln(OutFile,'Invalid User Name Test');
    Service := FirebirdAPI.GetServiceManager(ServerName,TCP,SPB);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
  SPB.Find(isc_spb_user_name).setAsString(Owner.GetUserName);
  SPB.Find(isc_spb_password).setAsString('Bad pwd');
  try
    writeln(OutFile,'Invalid password Test');
    Service := FirebirdAPI.GetServiceManager(ServerName,TCP,SPB);
  except on E: Exception do
    writeln(OutFile,'Error Handled: ',E.Message);
  end;
end;

function TTest16.TestTitle: AnsiString;
begin
  Result := 'Test 16: Error handling';
end;

procedure TTest16.RunTest(CharSet: AnsiString; SQLDialect: integer);
begin
  FirebirdAPI.GetStatus.SetIBDataBaseErrorMessages([ShowSQLCode,ShowSQLMessage,ShowIBMessage]);;
  DBTests(Charset,SQLDialect);
  ServiceTests(Charset,SQLDialect);
end;

initialization
  RegisterTest(TTest16);
end.

Revision:	402
Committed:	Mon Aug 1 10:07:24 2022 UTC (2 years, 4 months ago) by tony
Content type:	text/x-pascal
File size:	8493 byte(s)
Log Message:	IBX Release 2.5.0
#	User	Rev	Content
1	tony	315	(*
2			* Firebird Interface (fbintf) Test suite. This program is used to
3			* test the Firebird Pascal Interface and provide a semi-automated
4			* pass/fail check for each test.
5			*
6			* The contents of this file are subject to the Initial Developer's
7			* Public License Version 1.0 (the "License"); you may not use this
8			* file except in compliance with the License. You may obtain a copy
9			* of the License here:
10			*
11			* http://www.firebirdsql.org/index.php?op=doc&id=idpl
12			*
13			* Software distributed under the License is distributed on an "AS
14			* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
15			* implied. See the License for the specific language governing rights
16			* and limitations under the License.
17			*
18			* The Initial Developer of the Original Code is Tony Whyman.
19			*
20			* The Original Code is (C) 2016 Tony Whyman, MWA Software
21			* (http://www.mwasoftware.co.uk).
22			*
23			* All Rights Reserved.
24			*
25			* Contributor(s): ______________________________________.
26			*
27			*)
28
29	tony	45	unit Test16;
30	tony	56	{$IFDEF MSWINDOWS}
31			{$DEFINE WINDOWS}
32			{$ENDIF}
33	tony	45
34	tony	56	{$IFDEF FPC}
35			{$mode delphi}
36	tony	45	{$codepage UTF8}
37	tony	56	{$ENDIF}
38	tony	45
39			{Test 16: Error handling}
40
41			{ This test tests for correct responses to various error conditions:
42
43			- Malformed database name.
44			- Invalid User Name
45			- Invalid password
46			- Invalid Update SQL Statement
47			- Invalid Select SQL
48			- Transaction not started
49			- Invalid parameter by name when should be positional
50			- Invalid server name
51			- invalid user name - logon to server
52			- invalid password
53			}
54
55			interface
56
57			uses
58	tony	315	Classes, SysUtils, TestApplication, FBTestApp, IB;
59	tony	45
60			type
61
62			{ TTest16 }
63
64	tony	315	TTest16 = class(TFBTestBase)
65	tony	45	private
66	tony	56	procedure DBTests(CharSet: AnsiString; SQLDialect: integer);
67			procedure ServiceTests(CharSet: AnsiString; SQLDialect: integer);
68	tony	45	public
69	tony	56	function TestTitle: AnsiString; override;
70			procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
71	tony	45	end;
72
73
74			implementation
75
76			{ TTest16 }
77
78	tony	56	procedure TTest16.DBTests(CharSet: AnsiString; SQLDialect: integer);
79	tony	45	var DPB: IDPB;
80			Attachment: IAttachment;
81			Transaction: ITransaction;
82			Statement: IStatement;
83			begin
84			DPB := FirebirdAPI.AllocateDPB;
85			DPB.Add(isc_dpb_user_name).setAsString(Owner.GetUserName);
86			DPB.Add(isc_dpb_password).setAsString(Owner.GetPassword);
87			DPB.Add(isc_dpb_lc_ctype).setAsString('UTF8');
88			try
89			writeln(OutFile,'Invalid Database Name Test');
90			Attachment := FirebirdAPI.OpenDatabase('localhost:Malformed Name',DPB);
91			except on E: Exception do
92			writeln(OutFile,'Error Handled: ',E.Message);
93			end;
94			DPB.Find(isc_dpb_user_name).setAsString('Captain Nemo');
95			try
96			writeln(OutFile,'Invalid User Name Test');
97			Attachment := FirebirdAPI.OpenDatabase(Owner.GetEmployeeDatabaseName,DPB);
98			except on E: Exception do
99			writeln(OutFile,'Error Handled: ',E.Message);
100			end;
101			DPB.Find(isc_dpb_user_name).setAsString(Owner.GetUserName);
102			DPB.Find(isc_dpb_password).setAsString('not a pwd');
103			try
104			writeln(OutFile,'Invalid password Test');
105			Attachment := FirebirdAPI.OpenDatabase(Owner.GetEmployeeDatabaseName,DPB);
106			except on E: Exception do
107			writeln(OutFile,'Error Handled: ',E.Message);
108			end;
109			DPB.Find(isc_dpb_password).setAsString(Owner.GetPassword);
110			Attachment := FirebirdAPI.OpenDatabase(Owner.GetEmployeeDatabaseName,DPB);
111			Transaction := Attachment.StartTransaction([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],taRollback);
112			try
113			writeln(OutFile,'Invalid Prepare SQL Test');
114			Statement := Attachment.Prepare(Transaction,'Update Employee Set Unknown_Date = ? Where EMP_NO = ?',3);
115			except on E: Exception do
116			writeln(OutFile,'Error Handled: ',E.Message);
117			end;
118			try
119			writeln(OutFile,'Invalid Open Cursor SQL Test');
120			Attachment.OpenCursorAtStart(Transaction,
121			'Select X,count(*) As Counter from EMPLOYEE',3);
122			except on E: Exception do
123			writeln(OutFile,'Error Handled: ',E.Message);
124			end;
125			Transaction.Rollback;
126			try
127			writeln(OutFile,'Transaction not started Test');
128			Attachment.OpenCursorAtStart(Transaction,
129			'Select count(*) As Counter from EMPLOYEE',3);
130			except on E: Exception do
131			writeln(OutFile,'Error Handled: ',E.Message);
132			end;
133			Transaction.Start;
134			try
135			writeln(OutFile,'Invalid Param SQL Type Test');
136			Statement := Attachment.Prepare(Transaction,'Update Employee Set Hire_Date = ? Where EMP_NO = ?',3);
137			Statement.SQLParams.ByName('EMP_NO').AsDate := EncodeDate(2016,11,5);
138			except on E: Exception do
139			writeln(OutFile,'Error Handled: ',E.Message);
140			end;
141	tony	270	Transaction.Rollback;
142			Transaction.Start;
143			try
144			writeln(OutFile,'Case sensitive Param SQL Test');
145			Statement := Attachment.PrepareWithNamedParameters(Transaction,'Update Employee Set Hire_Date = :Hire_Date Where emp_no = :emp_no',3,false,true);
146			Statement.SQLParams.ByName('Hire_Date').AsDate := EncodeDate(2016,11,5);
147			Statement.SQLParams.ByName('emp_no').AsInteger := 1;
148			Statement.SQLParams.ByName('EMP_NO').AsInteger := 1;
149			except on E: Exception do
150			writeln(OutFile,'Error Handled: ',E.Message);
151			end;
152	tony	347	Transaction.Rollback;
153			Transaction.Start;
154			writeln(Outfile,'Stale Reference Check');
155			writeln(Outfile,'First test correct usage');
156			Statement := Attachment.Prepare(Transaction,'Select count(*) As Counter from EMPLOYEE Where Hire_Date < ?',3);
157			Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
158			ReportResults(Statement);
159			try
160			writeln(Outfile,'New Transaction before param set');
161			Statement.Prepare(Transaction);
162			Transaction.Rollback;
163			Transaction.Start;
164			Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
165			ReportResults(Statement);
166			except on E: Exception do
167			writeln(OutFile,'Error Handled: ',E.Message);
168			end;
169			Transaction.Rollback;
170			Transaction.Start;
171			try
172			writeln(Outfile,'New Transaction before Open Cursor');
173			Statement.Prepare(Transaction);
174			Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
175			Transaction.Rollback;
176			Transaction.Start;
177			ReportResults(Statement);
178			except on E: Exception do
179			writeln(OutFile,'Error Handled: ',E.Message);
180			end;
181			Transaction.Rollback;
182			Transaction.Start;
183			writeln(Outfile,'Stop Stale Reference Checks');
184			Statement.SetStaleReferenceChecks(false);
185			try
186			writeln(Outfile,'New Transaction before param set');
187			Statement.Prepare(Transaction);
188			Transaction.Rollback;
189			Transaction.Start;
190			Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
191			ReportResults(Statement);
192			except on E: Exception do
193			writeln(OutFile,'Error Handled: ',E.Message);
194			end;
195			try
196			writeln(Outfile,'New Transaction before Open Cursor');
197			Statement.Prepare(Transaction);
198			Statement.SQLParams[0].AsDate := EncodeDate(2016,11,5);
199			Transaction.Rollback;
200			Transaction.Start;
201			ReportResults(Statement);
202			except on E: Exception do
203			writeln(OutFile,'Error Handled: ',E.Message);
204			end;
205	tony	45	end;
206
207	tony	56	procedure TTest16.ServiceTests(CharSet: AnsiString; SQLDialect: integer);
208	tony	45	var SPB: ISPB;
209			Service: IServiceManager;
210	tony	56	ServerName: AnsiString;
211			DBName: AnsiString;
212	tony	45	begin
213			if not FirebirdAPI.HasServiceAPI then Exit;
214
215	tony	315	DBName := ExtractDBName(Owner.GetEmployeeDatabaseName);
216	tony	308	ServerName := Owner.Server;
217	tony	45
218			SPB := FirebirdAPI.AllocateSPB;
219			SPB.Add(isc_spb_user_name).setAsString(Owner.GetUserName);
220			SPB.Add(isc_spb_password).setAsString(Owner.GetPassword);
221			try
222			writeln(OutFile,'Invalid Server Name Test');
223			Service := FirebirdAPI.GetServiceManager('unknown',TCP,SPB);
224			except on E: Exception do
225			writeln(OutFile,'Error Handled: ',E.Message);
226			end;
227
228			SPB.Find(isc_spb_user_name).setAsString('Captain Nemo');
229			try
230			writeln(OutFile,'Invalid User Name Test');
231			Service := FirebirdAPI.GetServiceManager(ServerName,TCP,SPB);
232			except on E: Exception do
233			writeln(OutFile,'Error Handled: ',E.Message);
234			end;
235			SPB.Find(isc_spb_user_name).setAsString(Owner.GetUserName);
236			SPB.Find(isc_spb_password).setAsString('Bad pwd');
237			try
238			writeln(OutFile,'Invalid password Test');
239			Service := FirebirdAPI.GetServiceManager(ServerName,TCP,SPB);
240			except on E: Exception do
241			writeln(OutFile,'Error Handled: ',E.Message);
242			end;
243			end;
244
245	tony	56	function TTest16.TestTitle: AnsiString;
246	tony	45	begin
247			Result := 'Test 16: Error handling';
248			end;
249
250	tony	56	procedure TTest16.RunTest(CharSet: AnsiString; SQLDialect: integer);
251	tony	45	begin
252	tony	402	FirebirdAPI.GetStatus.SetIBDataBaseErrorMessages([ShowSQLCode,ShowSQLMessage,ShowIBMessage]);;
253	tony	45	DBTests(Charset,SQLDialect);
254			ServiceTests(Charset,SQLDialect);
255			end;
256
257			initialization
258			RegisterTest(TTest16);
259			end.
260