| 2265 |
kivins |
1 |
//---------------------------------------------------------------------------
|
|
|
2 |
|
|
|
3 |
#include <vcl.h>
|
|
|
4 |
#pragma hdrstop
|
|
|
5 |
#include <vector>
|
|
|
6 |
#include <map>
|
|
|
7 |
|
|
|
8 |
#include "TestDirectorLogin.h"
|
|
|
9 |
#include "TestDirectorImport.h"
|
|
|
10 |
#include "DataModule.h"
|
|
|
11 |
//---------------------------------------------------------------------------
|
|
|
12 |
#pragma package(smart_init)
|
|
|
13 |
#pragma link "AdvMemo"
|
|
|
14 |
#pragma resource "*.dfm"
|
|
|
15 |
TTestDirectorImportForm *TestDirectorImportForm;
|
|
|
16 |
//---------------------------------------------------------------------------
|
|
|
17 |
|
|
|
18 |
static TestDirectorNodeList_t TestDirectorNodes;
|
|
|
19 |
static TestDirectorNodeMap_t TestDirectorNodeMap;
|
|
|
20 |
static TestDirectorNodeMap_t TestDirectorScenarioMap;
|
|
|
21 |
|
|
|
22 |
//---------------------------------------------------------------------------
|
|
|
23 |
__fastcall TTestDirectorImportForm::TTestDirectorImportForm(TComponent* Owner)
|
|
|
24 |
: TForm(Owner)
|
|
|
25 |
{
|
|
|
26 |
}
|
|
|
27 |
//---------------------------------------------------------------------------
|
|
|
28 |
void __fastcall TTestDirectorImportForm::FormClose(TObject *Sender,
|
|
|
29 |
TCloseAction &Action)
|
|
|
30 |
{
|
|
|
31 |
TestDirectorConnection->Connected = false;
|
|
|
32 |
}
|
|
|
33 |
|
|
|
34 |
//---------------------------------------------------------------------------
|
|
|
35 |
|
|
|
36 |
const bool TTestDirectorImportForm::isTestCase( const AnsiString & description )
|
|
|
37 |
{
|
|
|
38 |
const AnsiString code = description.SubString( 1, 3 );
|
|
|
39 |
|
|
|
40 |
return ( ( code == "STC" ) || ( code == "SDD" ) || ( code == "SRQ" ) );
|
|
|
41 |
}
|
|
|
42 |
|
|
|
43 |
//---------------------------------------------------------------------------
|
|
|
44 |
|
|
|
45 |
void TTestDirectorImportForm::ShowForm( const AnsiString &project, int iteration )
|
|
|
46 |
{
|
|
|
47 |
m_project = project;
|
|
|
48 |
m_iteration = iteration;
|
|
|
49 |
|
|
|
50 |
if (TestDirectorLoginForm->Login( TestDirectorConnection ) )
|
|
|
51 |
{
|
|
|
52 |
ShowModal();
|
|
|
53 |
|
|
|
54 |
TestDirectorConnection->Connected = false; // Break Connection
|
|
|
55 |
|
|
|
56 |
try
|
|
|
57 |
{
|
|
|
58 |
TestDirectorNodeList_t::iterator itr = TestDirectorNodes.begin();
|
|
|
59 |
while (itr != TestDirectorNodes.end())
|
|
|
60 |
{
|
|
|
61 |
TestDirectorNode *td_node = (*itr);
|
|
|
62 |
|
|
|
63 |
delete td_node;
|
|
|
64 |
|
|
|
65 |
++itr;
|
|
|
66 |
}
|
|
|
67 |
}
|
|
|
68 |
catch(...)
|
|
|
69 |
{
|
|
|
70 |
}
|
|
|
71 |
|
|
|
72 |
TestDirectorNodes.clear();
|
|
|
73 |
TestDirectorNodeMap.clear();
|
|
|
74 |
TestDirectorScenarioMap.clear();
|
|
|
75 |
}
|
|
|
76 |
else
|
|
|
77 |
{
|
|
|
78 |
MessageDlg("Failed to connect to Test Director", mtError, TMsgDlgButtons() << mbOK, 0);
|
|
|
79 |
}
|
|
|
80 |
}
|
|
|
81 |
|
|
|
82 |
//---------------------------------------------------------------------------
|
|
|
83 |
|
|
|
84 |
void __fastcall TTestDirectorImportForm::LoadTestDataScenarioData(unsigned int &root_node, AnsiString &root_node_name)
|
|
|
85 |
{
|
|
|
86 |
TADOQuery *query = NULL;
|
|
|
87 |
AnsiString sql_statement;
|
|
|
88 |
|
|
|
89 |
try
|
|
|
90 |
{
|
|
|
91 |
query = new TADOQuery(this);
|
|
|
92 |
query->Connection = TestDirectorConnection;
|
|
|
93 |
|
|
|
94 |
// -----------------------------------------------------------------------
|
|
|
95 |
|
|
|
96 |
sql_statement = "SELECT AL_ITEM_ID,AL_FATHER_ID,AL_DESCRIPTION,AL_MEMO,AL_NO_OF_SONS "
|
|
|
97 |
"FROM TD.ALL_LISTS "
|
|
|
98 |
"ORDER BY TD.AL_DESCRIPTION";
|
|
|
99 |
|
|
|
100 |
query->SQL->Text = sql_statement;
|
|
|
101 |
query->Open();
|
|
|
102 |
if (query->RecordCount > 0)
|
|
|
103 |
{
|
|
|
104 |
// int count_test_cases = query->RecordCount;
|
|
|
105 |
while (!query->Eof)
|
|
|
106 |
{
|
|
|
107 |
unsigned short item_id = query->FieldByName("AL_ITEM_ID")->AsInteger;
|
|
|
108 |
unsigned short father_id = query->FieldByName("AL_FATHER_ID")->AsInteger;
|
|
|
109 |
|
|
|
110 |
TestDirectorNode *td_node = new TestDirectorNode;
|
|
|
111 |
TestDirectorNodes.push_back(td_node);
|
|
|
112 |
|
|
|
113 |
td_node->nodetype = TESTCASE;
|
|
|
114 |
td_node->name = query->FieldByName("AL_DESCRIPTION")->AsString;
|
|
|
115 |
td_node->parentnode = father_id;
|
|
|
116 |
td_node->subjectnode = item_id;
|
|
|
117 |
td_node->text1 = query->FieldByName("AL_MEMO")->AsString;
|
|
|
118 |
|
|
|
119 |
// Pick out the SQT node for the moment - TODO revisit this
|
|
|
120 |
if (td_node->name == "SQT")
|
|
|
121 |
{
|
|
|
122 |
root_node = item_id;
|
|
|
123 |
root_node_name = td_node->name;
|
|
|
124 |
}
|
|
|
125 |
|
|
|
126 |
TestDirectorNodePair_t pair(item_id, td_node);
|
|
|
127 |
TestDirectorNodeMap.insert( pair );
|
|
|
128 |
|
|
|
129 |
query->Next();
|
|
|
130 |
} // while
|
|
|
131 |
|
|
|
132 |
// Build the Parent/Child linkages
|
|
|
133 |
TestDirectorNodeMap_t::iterator itr = TestDirectorNodeMap.begin();
|
|
|
134 |
while (itr != TestDirectorNodeMap.end())
|
|
|
135 |
{
|
|
|
136 |
TestDirectorNode *td_node = (*itr).second;
|
|
|
137 |
|
|
|
138 |
TestDirectorNodeMap_t::iterator parent_itr = TestDirectorNodeMap.find( td_node->parentnode );
|
|
|
139 |
if (parent_itr != TestDirectorNodeMap.end())
|
|
|
140 |
{
|
|
|
141 |
TestDirectorNode *parent_td_node = (*parent_itr).second;
|
|
|
142 |
|
|
|
143 |
td_node->parent = parent_td_node;
|
|
|
144 |
|
|
|
145 |
parent_td_node->children.push_back( td_node );
|
|
|
146 |
}
|
|
|
147 |
|
|
|
148 |
++itr;
|
|
|
149 |
} // while
|
|
|
150 |
}
|
|
|
151 |
// -----------------------------------------------------------------------
|
|
|
152 |
}
|
|
|
153 |
catch(...)
|
|
|
154 |
{
|
|
|
155 |
}
|
|
|
156 |
|
|
|
157 |
delete query;
|
|
|
158 |
}
|
|
|
159 |
|
|
|
160 |
//---------------------------------------------------------------------------
|
|
|
161 |
|
|
|
162 |
void __fastcall TTestDirectorImportForm::LoadTestScenarios(TestDirectorNode *parent_td_node)
|
|
|
163 |
{
|
|
|
164 |
TADOQuery *query = NULL;
|
|
|
165 |
AnsiString sql_statement;
|
|
|
166 |
|
|
|
167 |
try
|
|
|
168 |
{
|
|
|
169 |
query = new TADOQuery(this);
|
|
|
170 |
query->Connection = TestDirectorConnection;
|
|
|
171 |
|
|
|
172 |
// Load Test Scenarios
|
|
|
173 |
sql_statement.sprintf("SELECT TS_TEST_ID,TS_SUBJECT,TS_NAME,TS_DESCRIPTION "
|
|
|
174 |
"FROM TD.TEST "
|
|
|
175 |
"WHERE TS_SUBJECT=%d "
|
|
|
176 |
"ORDER BY TS_NAME",
|
|
|
177 |
parent_td_node->subjectnode);
|
|
|
178 |
|
|
|
179 |
query->SQL->Text = sql_statement;
|
|
|
180 |
query->Open();
|
|
|
181 |
// int count_test_scenarios = query->RecordCount;
|
|
|
182 |
while (!query->Eof)
|
|
|
183 |
{
|
|
|
184 |
AnsiString name = query->FieldByName("TS_NAME")->AsString;
|
|
|
185 |
AnsiString description = query->FieldByName("TS_DESCRIPTION")->AsString;
|
|
|
186 |
// unsigned int subject_id = query->FieldByName("TS_SUBJECT")->AsInteger;
|
|
|
187 |
unsigned int test_id = query->FieldByName("TS_TEST_ID")->AsInteger;
|
|
|
188 |
|
|
|
189 |
TestDirectorNode *td_node = new TestDirectorNode;
|
|
|
190 |
TestDirectorNodes.push_back(td_node);
|
|
|
191 |
|
|
|
192 |
td_node->nodetype = SCENARIO;
|
|
|
193 |
td_node->name = name;
|
|
|
194 |
td_node->subjectnode = test_id;
|
|
|
195 |
td_node->text1 = description;
|
|
|
196 |
|
|
|
197 |
TestDirectorNodePair_t pair(test_id, td_node);
|
|
|
198 |
TestDirectorScenarioMap.insert( pair );
|
|
|
199 |
|
|
|
200 |
td_node->parent = parent_td_node;
|
|
|
201 |
parent_td_node->children.push_back( td_node );
|
|
|
202 |
|
|
|
203 |
query->Next();
|
|
|
204 |
} // while
|
|
|
205 |
query->Close();
|
|
|
206 |
}
|
|
|
207 |
catch(...)
|
|
|
208 |
{
|
|
|
209 |
}
|
|
|
210 |
|
|
|
211 |
delete query;
|
|
|
212 |
}
|
|
|
213 |
|
|
|
214 |
void __fastcall TTestDirectorImportForm::LoadTestSteps(TestDirectorNode *parent_td_node)
|
|
|
215 |
{
|
|
|
216 |
TADOQuery *query = NULL;
|
|
|
217 |
AnsiString sql_statement;
|
|
|
218 |
|
|
|
219 |
try
|
|
|
220 |
{
|
|
|
221 |
query = new TADOQuery(this);
|
|
|
222 |
query->Connection = TestDirectorConnection;
|
|
|
223 |
|
|
|
224 |
// Load the Test Scenario Steps
|
|
|
225 |
sql_statement.sprintf("SELECT DS_TEST_ID,DS_STEP_NAME,DS_DESCRIPTION,DS_EXPECTED "
|
|
|
226 |
"FROM TD.DESSTEPS "
|
|
|
227 |
"WHERE DS_TEST_ID=%d "
|
|
|
228 |
"ORDER BY DS_STEP_ORDER",
|
|
|
229 |
parent_td_node->subjectnode
|
|
|
230 |
);
|
|
|
231 |
query->SQL->Text = sql_statement;
|
|
|
232 |
query->Open();
|
|
|
233 |
// int count_test_steps = query->RecordCount;
|
|
|
234 |
while (!query->Eof)
|
|
|
235 |
{
|
|
|
236 |
int step_test_id = query->FieldByName("DS_TEST_ID")->AsInteger;
|
|
|
237 |
AnsiString step_name = query->FieldByName("DS_STEP_NAME")->AsString;
|
|
|
238 |
AnsiString step_description = query->FieldByName("DS_DESCRIPTION")->AsString;
|
|
|
239 |
AnsiString step_expected = query->FieldByName("DS_EXPECTED")->AsString;
|
|
|
240 |
|
|
|
241 |
TestDirectorNode *td_node = new TestDirectorNode;
|
|
|
242 |
TestDirectorNodes.push_back(td_node);
|
|
|
243 |
|
|
|
244 |
td_node->nodetype = TESTSTEP;
|
|
|
245 |
td_node->name = step_name;
|
|
|
246 |
td_node->subjectnode = step_test_id;
|
|
|
247 |
td_node->text1 = step_description;
|
|
|
248 |
td_node->text2 = step_expected;
|
|
|
249 |
|
|
|
250 |
td_node->parent = parent_td_node;
|
|
|
251 |
parent_td_node->test_steps.push_back( td_node );
|
|
|
252 |
|
|
|
253 |
query->Next();
|
|
|
254 |
} // while
|
|
|
255 |
}
|
|
|
256 |
catch(...)
|
|
|
257 |
{
|
|
|
258 |
}
|
|
|
259 |
|
|
|
260 |
delete query;
|
|
|
261 |
}
|
|
|
262 |
|
|
|
263 |
//---------------------------------------------------------------------------
|
|
|
264 |
|
|
|
265 |
void __fastcall TTestDirectorImportForm::FormShow(TObject *Sender)
|
|
|
266 |
{
|
|
|
267 |
TCursor Save_Cursor = Screen->Cursor;
|
|
|
268 |
Screen->Cursor = crHourGlass; // Show hourglass cursor
|
|
|
269 |
|
|
|
270 |
try
|
|
|
271 |
{
|
|
|
272 |
AnsiString root_node_name;
|
|
|
273 |
unsigned int root_node = 0;
|
|
|
274 |
|
|
|
275 |
LoadTestDataScenarioData(root_node, root_node_name);
|
|
|
276 |
|
|
|
277 |
TTreeNode *node = NULL;
|
|
|
278 |
TestCaseTreeView->Items->Clear();
|
|
|
279 |
node = TestCaseTreeView->Items->Add(NULL, root_node_name);
|
|
|
280 |
node->ImageIndex = 0;
|
|
|
281 |
node->SelectedIndex = 1;
|
|
|
282 |
|
|
|
283 |
DrawSubTree(TestCaseTreeView, node, TESTCASE, root_node); // Start at the Subject Root
|
|
|
284 |
}
|
|
|
285 |
__finally
|
|
|
286 |
{
|
|
|
287 |
Screen->Cursor = Save_Cursor; // always restore the cursor
|
|
|
288 |
}
|
|
|
289 |
}
|
|
|
290 |
|
|
|
291 |
//---------------------------------------------------------------------------
|
|
|
292 |
|
|
|
293 |
void TTestDirectorImportForm::DrawSubTree(TTreeView *tree, TTreeNode *node, int nodetype, int parent_id)
|
|
|
294 |
{
|
|
|
295 |
if (nodetype == TESTSTEP)
|
|
|
296 |
{
|
|
|
297 |
TestDirectorNodeMap_t::iterator itr = TestDirectorScenarioMap.find( parent_id );
|
|
|
298 |
|
|
|
299 |
if (itr != TestDirectorScenarioMap.end())
|
|
|
300 |
{
|
|
|
301 |
TestDirectorNode *scenario_node = (*itr).second;
|
|
|
302 |
|
|
|
303 |
DrawScenarioSteps(scenario_node);
|
|
|
304 |
}
|
|
|
305 |
}
|
|
|
306 |
else
|
|
|
307 |
{
|
|
|
308 |
TestDirectorNodeMap_t::iterator itr = TestDirectorNodeMap.find( parent_id );
|
|
|
309 |
|
|
|
310 |
if (itr != TestDirectorNodeMap.end())
|
|
|
311 |
{
|
|
|
312 |
if ((*itr).second->children.size() > 0)
|
|
|
313 |
{
|
|
|
314 |
TestDirectorNodeList_t::iterator child_itr = (*itr).second->children.begin();
|
|
|
315 |
|
|
|
316 |
while (child_itr != (*itr).second->children.end())
|
|
|
317 |
{
|
|
|
318 |
TestDirectorNode *td_node = (*child_itr);
|
|
|
319 |
|
|
|
320 |
if (td_node->nodetype == nodetype)
|
|
|
321 |
{
|
|
|
322 |
switch(td_node->nodetype)
|
|
|
323 |
{
|
|
|
324 |
case TESTCASE:
|
|
|
325 |
{
|
|
|
326 |
TTreeNode *subtree = tree->Items->AddChildObject(node, td_node->name, (TObject *)td_node);
|
|
|
327 |
subtree->ImageIndex = 0;
|
|
|
328 |
subtree->SelectedIndex = 1;
|
|
|
329 |
|
|
|
330 |
DrawSubTree(tree, subtree, nodetype, td_node->subjectnode);
|
|
|
331 |
}
|
|
|
332 |
break;
|
|
|
333 |
|
|
|
334 |
case SCENARIO:
|
|
|
335 |
{
|
|
|
336 |
/*TTreeNode *subtree =*/ tree->Items->AddChildObject(node, td_node->name, (TObject *)td_node);
|
|
|
337 |
}
|
|
|
338 |
break;
|
|
|
339 |
} // switch
|
|
|
340 |
}
|
|
|
341 |
|
|
|
342 |
++child_itr;
|
|
|
343 |
} // for
|
|
|
344 |
}
|
|
|
345 |
}
|
|
|
346 |
}
|
|
|
347 |
}
|
|
|
348 |
|
|
|
349 |
//---------------------------------------------------------------------------
|
|
|
350 |
|
|
|
351 |
void TTestDirectorImportForm::DrawScenarioSteps(TestDirectorNode *scenario_node)
|
|
|
352 |
{
|
|
|
353 |
TTreeNode *node = NULL;
|
|
|
354 |
TestStepTreeView->Items->Clear();
|
|
|
355 |
node = TestStepTreeView->Items->Add(NULL, "Test Steps");
|
|
|
356 |
node->ImageIndex = 0;
|
|
|
357 |
node->SelectedIndex = 1;
|
|
|
358 |
|
|
|
359 |
TestDirectorNodeList_t::iterator itr = scenario_node->test_steps.begin();
|
|
|
360 |
while (itr != scenario_node->test_steps.end())
|
|
|
361 |
{
|
|
|
362 |
TestDirectorNode *td_node = (*itr);
|
|
|
363 |
|
|
|
364 |
/*TTreeNode *step_node = */TestStepTreeView->Items->AddChildObject(node, td_node->name, (TObject *)td_node);
|
|
|
365 |
|
|
|
366 |
++itr;
|
|
|
367 |
}
|
|
|
368 |
|
|
|
369 |
node->Expand(true);
|
|
|
370 |
}
|
|
|
371 |
|
|
|
372 |
//---------------------------------------------------------------------------
|
|
|
373 |
|
|
|
374 |
void __fastcall TTestDirectorImportForm::TestCaseTreeViewChange(
|
|
|
375 |
TObject *Sender, TTreeNode *Node)
|
|
|
376 |
{
|
|
|
377 |
TCursor Save_Cursor = Screen->Cursor;
|
|
|
378 |
Screen->Cursor = crHourGlass; // Show hourglass cursor
|
|
|
379 |
|
|
|
380 |
try
|
|
|
381 |
{
|
|
|
382 |
TestCaseMemo->Clear();
|
|
|
383 |
TestScenarioMemo->Clear();
|
|
|
384 |
|
|
|
385 |
TestDirectorNode *td_node = (TestDirectorNode *)(Node->Data);
|
|
|
386 |
|
|
|
387 |
if (td_node != NULL)
|
|
|
388 |
{
|
|
|
389 |
TestScenarioPanel->Caption = td_node->name;
|
|
|
390 |
|
|
|
391 |
TestCaseMemo->Lines->Text = td_node->text1;
|
|
|
392 |
TestCaseMemo->WordWrap = wwRightMargin;
|
|
|
393 |
TestCaseMemo->Update();
|
|
|
394 |
|
|
|
395 |
if (td_node->children.size() == 0)
|
|
|
396 |
{
|
|
|
397 |
LoadTestScenarios(td_node);
|
|
|
398 |
}
|
|
|
399 |
|
|
|
400 |
TTreeNode *node = NULL;
|
|
|
401 |
|
|
|
402 |
TestScenarioTreeView->Items->Clear();
|
|
|
403 |
TestStepTreeView->Items->Clear();
|
|
|
404 |
|
|
|
405 |
node = TestScenarioTreeView->Items->Add(NULL, "Test Scenarios");
|
|
|
406 |
node->ImageIndex = 0;
|
|
|
407 |
node->SelectedIndex = 1;
|
|
|
408 |
|
|
|
409 |
DrawSubTree(TestScenarioTreeView, node, SCENARIO, td_node->subjectnode);
|
|
|
410 |
|
|
|
411 |
node->Expand(true);
|
|
|
412 |
}
|
|
|
413 |
}
|
|
|
414 |
__finally
|
|
|
415 |
{
|
|
|
416 |
Screen->Cursor = Save_Cursor; // always restore the cursor
|
|
|
417 |
}
|
|
|
418 |
}
|
|
|
419 |
//---------------------------------------------------------------------------
|
|
|
420 |
|
|
|
421 |
AnsiString TTestDirectorImportForm::ProcessQuotedString(const AnsiString &source)
|
|
|
422 |
{
|
|
|
423 |
AnsiString result;
|
|
|
424 |
const char *p = source.c_str();
|
|
|
425 |
|
|
|
426 |
for (int i=0; i<source.Length(); i++)
|
|
|
427 |
{
|
|
|
428 |
if (*p == '\'')
|
|
|
429 |
{
|
|
|
430 |
result += *p;
|
|
|
431 |
}
|
|
|
432 |
|
|
|
433 |
if (*p == '\"')
|
|
|
434 |
{
|
|
|
435 |
result += "''";
|
|
|
436 |
}
|
|
|
437 |
else
|
|
|
438 |
{
|
|
|
439 |
result += *p;
|
|
|
440 |
}
|
|
|
441 |
|
|
|
442 |
p++;
|
|
|
443 |
}
|
|
|
444 |
|
|
|
445 |
return result;
|
|
|
446 |
}
|
|
|
447 |
|
|
|
448 |
//---------------------------------------------------------------------------
|
|
|
449 |
|
|
|
450 |
void __fastcall TTestDirectorImportForm::ImportFromTestDirector1Click(
|
|
|
451 |
TObject *Sender)
|
|
|
452 |
{
|
|
|
453 |
TADOQuery *query = NULL;
|
|
|
454 |
|
|
|
455 |
TCursor Save_Cursor = Screen->Cursor;
|
|
|
456 |
Screen->Cursor = crHourGlass; // Show hourglass cursor
|
|
|
457 |
|
|
|
458 |
try
|
|
|
459 |
{
|
|
|
460 |
query = new TADOQuery(this);
|
|
|
461 |
query->Connection = Data_Module->IntegrationDBConnection;
|
|
|
462 |
|
|
|
463 |
Data_Module->IntegrationDBConnection->BeginTrans();
|
|
|
464 |
|
|
|
465 |
for (unsigned i=0; i<TestCaseTreeView->SelectionCount; i++)
|
|
|
466 |
{
|
|
|
467 |
TTreeNode *selected_node = TestCaseTreeView->Selections[i];
|
|
|
468 |
|
|
|
469 |
AnsiString current_text_case_level;
|
|
|
470 |
|
|
|
471 |
ProcessSubtree(TestCaseTreeView, selected_node, query, current_text_case_level);
|
|
|
472 |
}
|
|
|
473 |
|
|
|
474 |
// Process Children
|
|
|
475 |
TTreeNode *scenario_root_node = TestScenarioTreeView->TopItem;
|
|
|
476 |
if (scenario_root_node != NULL)
|
|
|
477 |
{
|
|
|
478 |
AnsiString current_text_case_level;
|
|
|
479 |
|
|
|
480 |
ProcessSubtree(TestScenarioTreeView, scenario_root_node, query, current_text_case_level);
|
|
|
481 |
}
|
|
|
482 |
|
|
|
483 |
if (Data_Module->IntegrationDBConnection->InTransaction)
|
|
|
484 |
{
|
|
|
485 |
Data_Module->IntegrationDBConnection->CommitTrans();
|
|
|
486 |
}
|
|
|
487 |
}
|
|
|
488 |
__finally
|
|
|
489 |
{
|
|
|
490 |
delete query;
|
|
|
491 |
|
|
|
492 |
if (Data_Module->IntegrationDBConnection->InTransaction)
|
|
|
493 |
{
|
|
|
494 |
Data_Module->IntegrationDBConnection->RollbackTrans();
|
|
|
495 |
}
|
|
|
496 |
|
|
|
497 |
Screen->Cursor = Save_Cursor;
|
|
|
498 |
}
|
|
|
499 |
}
|
|
|
500 |
|
|
|
501 |
//---------------------------------------------------------------------------
|
|
|
502 |
|
|
|
503 |
void TTestDirectorImportForm::ProcessSubtree(TTreeView *treeview, TTreeNode *node, TADOQuery *query, AnsiString current_text_case_level)
|
|
|
504 |
{
|
|
|
505 |
ProcessTDNode(node, query, current_text_case_level);
|
|
|
506 |
|
|
|
507 |
// Process Children
|
|
|
508 |
TTreeNode *child_node = node->getFirstChild();
|
|
|
509 |
|
|
|
510 |
if (child_node != NULL)
|
|
|
511 |
{
|
|
|
512 |
do
|
|
|
513 |
{
|
|
|
514 |
ProcessSubtree(treeview, child_node, query, current_text_case_level);
|
|
|
515 |
|
|
|
516 |
child_node = node->GetNextChild(child_node);
|
|
|
517 |
} while (child_node != NULL);
|
|
|
518 |
}
|
|
|
519 |
}
|
|
|
520 |
|
|
|
521 |
//---------------------------------------------------------------------------
|
|
|
522 |
|
|
|
523 |
void TTestDirectorImportForm::ProcessTDNode(TTreeNode *selected_node, TADOQuery *query, AnsiString ¤t_text_case_level)
|
|
|
524 |
{
|
|
|
525 |
AnsiString sql_statement;
|
|
|
526 |
TestDirectorNode *td_node = (TestDirectorNode *)(selected_node->Data);
|
|
|
527 |
|
|
|
528 |
if(td_node != NULL)
|
|
|
529 |
{
|
|
|
530 |
switch(td_node->nodetype)
|
|
|
531 |
{
|
|
|
532 |
case SUBJECT:
|
|
|
533 |
// Do nothing
|
|
|
534 |
break;
|
|
|
535 |
|
|
|
536 |
case TESTCASE:
|
|
|
537 |
{
|
|
|
538 |
AnsiString usecase_id = td_node->name.SubString(1, td_node->name.Pos(" ")-1);
|
|
|
539 |
|
|
|
540 |
if ( (!usecase_id.IsEmpty() && isTestCase( usecase_id )) ||
|
|
|
541 |
!current_text_case_level.IsEmpty() )
|
|
|
542 |
{
|
|
|
543 |
AnsiString tc_name;
|
|
|
544 |
|
|
|
545 |
if (!usecase_id.IsEmpty() && isTestCase( usecase_id ))
|
|
|
546 |
{
|
|
|
547 |
tc_name = td_node->name.SubString(td_node->name.Pos(" ")+1, td_node->name.Length());
|
|
|
548 |
|
|
|
549 |
current_text_case_level = usecase_id;
|
|
|
550 |
|
|
|
551 |
sql_statement="";
|
|
|
552 |
sql_statement.sprintf("SELECT NAME, DESCRIPTION FROM TESTCASES "
|
|
|
553 |
"WHERE USECASE_ID='%s'",
|
|
|
554 |
usecase_id.c_str());
|
|
|
555 |
query->SQL->Text = sql_statement;
|
|
|
556 |
query->Open();
|
|
|
557 |
if (query->RecordCount == 0) // Test Case not found .. Insert it
|
|
|
558 |
{
|
|
|
559 |
sql_statement="";
|
|
|
560 |
sql_statement.sprintf("INSERT INTO TESTCASES (USECASE_ID, NAME, TESTCASE_ID, DESCRIPTION) "
|
|
|
561 |
"VALUES ('%s','%s','%s','%s')",
|
|
|
562 |
usecase_id.c_str(),
|
|
|
563 |
tc_name.c_str(),
|
|
|
564 |
usecase_id.c_str(),
|
|
|
565 |
ProcessQuotedString(td_node->text1).c_str()
|
|
|
566 |
);
|
|
|
567 |
|
|
|
568 |
query->SQL->Text = sql_statement;
|
|
|
569 |
query->ExecSQL();
|
|
|
570 |
}
|
|
|
571 |
else
|
|
|
572 |
{
|
|
|
573 |
// Existing Test Case found .. Update it
|
|
|
574 |
|
|
|
575 |
AnsiString desc = ProcessQuotedString(td_node->text1);
|
|
|
576 |
|
|
|
577 |
if ( (query->FieldByName("NAME")->AsString != tc_name) ||
|
|
|
578 |
(query->FieldByName("DESCRIPTION")->AsString != desc) )
|
|
|
579 |
{
|
|
|
580 |
sql_statement="";
|
|
|
581 |
sql_statement.sprintf("UPDATE TESTCASES SET NAME='%s',DESCRIPTION='%s' "
|
|
|
582 |
"WHERE USECASE_ID='%s'",
|
|
|
583 |
tc_name.c_str(),
|
|
|
584 |
desc.c_str(),
|
|
|
585 |
usecase_id.c_str()
|
|
|
586 |
);
|
|
|
587 |
|
|
|
588 |
query->SQL->Text = sql_statement;
|
|
|
589 |
query->ExecSQL();
|
|
|
590 |
}
|
|
|
591 |
}
|
|
|
592 |
}
|
|
|
593 |
}
|
|
|
594 |
}
|
|
|
595 |
break;
|
|
|
596 |
|
|
|
597 |
case SCENARIO:
|
|
|
598 |
{
|
|
|
599 |
TestDirectorNode *testcase_node = (TestDirectorNode *)(td_node->parent);
|
|
|
600 |
TestDirectorNode *parent_testcase_node = (TestDirectorNode *)(td_node->parent->parent);
|
|
|
601 |
|
|
|
602 |
AnsiString usecase_id = testcase_node->name.SubString(1, testcase_node->name.Pos(" ")-1);
|
|
|
603 |
AnsiString parent_usecase_id = parent_testcase_node->name.SubString(1, parent_testcase_node->name.Pos(" ")-1);
|
|
|
604 |
|
|
|
605 |
if ( (!usecase_id.IsEmpty() && isTestCase( usecase_id )) ||
|
|
|
606 |
(!parent_usecase_id.IsEmpty() && isTestCase( parent_usecase_id )) )
|
|
|
607 |
{
|
|
|
608 |
AnsiString tc_id = td_node->name.SubString(1, td_node->name.Pos(" ")-1);
|
|
|
609 |
AnsiString tc_name = td_node->name.SubString(td_node->name.Pos(" ")+1, td_node->name.Length());
|
|
|
610 |
|
|
|
611 |
current_text_case_level = tc_id;
|
|
|
612 |
|
|
|
613 |
const char *p = tc_id.c_str();
|
|
|
614 |
AnsiString tc_scenario_seqno;
|
|
|
615 |
|
|
|
616 |
// Skip to '.'
|
|
|
617 |
while ( (*p != '.') && (*p != '\0') )
|
|
|
618 |
{
|
|
|
619 |
p++;
|
|
|
620 |
}
|
|
|
621 |
if (*p == '.')
|
|
|
622 |
{
|
|
|
623 |
p++;
|
|
|
624 |
while ( (*p != '.') && (*p != '\0') )
|
|
|
625 |
{
|
|
|
626 |
tc_scenario_seqno += *p;
|
|
|
627 |
|
|
|
628 |
p++;
|
|
|
629 |
}
|
|
|
630 |
}
|
|
|
631 |
|
|
|
632 |
if ( (usecase_id.IsEmpty() || !isTestCase( usecase_id )) )
|
|
|
633 |
{
|
|
|
634 |
usecase_id = parent_usecase_id;
|
|
|
635 |
}
|
|
|
636 |
|
|
|
637 |
// Do we already have a matching TEST_SCENARIOS (examine Project,Iteration,TestCase_ID and Name) ?
|
|
|
638 |
|
|
|
639 |
sql_statement="";
|
|
|
640 |
sql_statement.sprintf("SELECT TESTCASE_SEQNO FROM TEST_SCENARIOS "
|
|
|
641 |
"WHERE PROJECT_CODE='%s' AND ITERATION=%d AND TESTCASE_ID='%s' AND NAME='%s'",
|
|
|
642 |
m_project.c_str(),
|
|
|
643 |
m_iteration,
|
|
|
644 |
usecase_id.c_str(),
|
|
|
645 |
tc_name.c_str());
|
|
|
646 |
query->SQL->Text = sql_statement;
|
|
|
647 |
query->Open();
|
|
|
648 |
if (query->RecordCount == 0) // Scenario not found
|
|
|
649 |
{
|
|
|
650 |
int next_testcase_seqno = 0;
|
|
|
651 |
|
|
|
652 |
if (tc_scenario_seqno.IsEmpty())
|
|
|
653 |
{
|
|
|
654 |
sql_statement="";
|
|
|
655 |
sql_statement.sprintf("SELECT MAX(TESTCASE_SEQNO) MAX_SEQNO FROM TEST_SCENARIOS "
|
|
|
656 |
"WHERE PROJECT_CODE='%s' AND ITERATION=%d AND TESTCASE_ID='%s'",
|
|
|
657 |
m_project.c_str(),
|
|
|
658 |
m_iteration,
|
|
|
659 |
usecase_id.c_str());
|
|
|
660 |
|
|
|
661 |
query->SQL->Text = sql_statement;
|
|
|
662 |
query->Open();
|
|
|
663 |
next_testcase_seqno = query->FieldByName("MAX_SEQNO")->AsInteger;
|
|
|
664 |
next_testcase_seqno++;
|
|
|
665 |
}
|
|
|
666 |
else
|
|
|
667 |
{
|
|
|
668 |
next_testcase_seqno = atoi(tc_scenario_seqno.c_str());
|
|
|
669 |
}
|
|
|
670 |
|
|
|
671 |
sql_statement="";
|
|
|
672 |
sql_statement.sprintf("INSERT INTO TEST_SCENARIOS (PROJECT_CODE,ITERATION,TESTCASE_ID,USECASE,NAME,DESCRIPTION,TESTCASE_SEQNO) "
|
|
|
673 |
"VALUES ('%s',%d,'%s','%s','%s','%s',%d)",
|
|
|
674 |
m_project.c_str(),
|
|
|
675 |
m_iteration,
|
|
|
676 |
usecase_id.c_str(),
|
|
|
677 |
usecase_id.c_str(),
|
|
|
678 |
tc_name.c_str(),
|
|
|
679 |
ProcessQuotedString(td_node->text1).c_str(),
|
|
|
680 |
next_testcase_seqno);
|
|
|
681 |
|
|
|
682 |
query->SQL->Text = sql_statement;
|
|
|
683 |
query->ExecSQL();
|
|
|
684 |
}
|
|
|
685 |
else
|
|
|
686 |
{
|
|
|
687 |
int next_testcase_seqno = 0;
|
|
|
688 |
|
|
|
689 |
if (tc_scenario_seqno.IsEmpty())
|
|
|
690 |
{
|
|
|
691 |
next_testcase_seqno = query->FieldByName("TESTCASE_SEQNO")->AsInteger;
|
|
|
692 |
}
|
|
|
693 |
else
|
|
|
694 |
{
|
|
|
695 |
next_testcase_seqno = atoi(tc_scenario_seqno.c_str());
|
|
|
696 |
}
|
|
|
697 |
|
|
|
698 |
|
|
|
699 |
sql_statement="";
|
|
|
700 |
sql_statement.sprintf("UPDATE TEST_SCENARIOS SET DESCRIPTION='%s',TESTCASE_SEQNO=%d "
|
|
|
701 |
"WHERE PROJECT_CODE='%s' AND ITERATION=%d AND TESTCASE_ID='%s' AND NAME='%s'",
|
|
|
702 |
ProcessQuotedString(td_node->text1).c_str(),
|
|
|
703 |
next_testcase_seqno,
|
|
|
704 |
m_project.c_str(),
|
|
|
705 |
m_iteration,
|
|
|
706 |
usecase_id.c_str(),
|
|
|
707 |
tc_name.c_str());
|
|
|
708 |
|
|
|
709 |
query->SQL->Text = sql_statement;
|
|
|
710 |
query->ExecSQL();
|
|
|
711 |
}
|
|
|
712 |
}
|
|
|
713 |
}
|
|
|
714 |
break;
|
|
|
715 |
|
|
|
716 |
case TESTSTEP:
|
|
|
717 |
{
|
|
|
718 |
TestDirectorNode *testcase_node = (TestDirectorNode *)(selected_node->Parent->Parent->Data);
|
|
|
719 |
AnsiString usecase_id = testcase_node->name.SubString(1, testcase_node->name.Pos(" ")-1);
|
|
|
720 |
|
|
|
721 |
TestDirectorNode *ts_node = (TestDirectorNode *)(selected_node->Parent->Data);
|
|
|
722 |
|
|
|
723 |
if ( !usecase_id.IsEmpty() && isTestCase( usecase_id ) )
|
|
|
724 |
{
|
|
|
725 |
AnsiString ts_name = ts_node->name.SubString(ts_node->name.Pos(" ")+1, ts_node->name.Length());
|
|
|
726 |
|
|
|
727 |
sql_statement="";
|
|
|
728 |
sql_statement.sprintf("SELECT TESTSCENARIO_NO FROM TEST_SCENARIOS "
|
|
|
729 |
"WHERE PROJECT_CODE='%s' AND ITERATION=%d AND TESTCASE_ID='%s' AND NAME='%s'",
|
|
|
730 |
m_project.c_str(),
|
|
|
731 |
m_iteration,
|
|
|
732 |
usecase_id.c_str(),
|
|
|
733 |
ts_name.c_str());
|
|
|
734 |
query->SQL->Text = sql_statement;
|
|
|
735 |
query->Open();
|
|
|
736 |
if (query->RecordCount == 1)
|
|
|
737 |
{
|
|
|
738 |
int testscenario_no = query->FieldByName("TESTSCENARIO_NO")->AsInteger;
|
|
|
739 |
|
|
|
740 |
sql_statement="";
|
|
|
741 |
sql_statement.sprintf("DELETE FROM TXNSPEC_STEPS WHERE TESTSCENARIO_NO=%d AND NAME='%s'",
|
|
|
742 |
testscenario_no,
|
|
|
743 |
td_node->name.c_str());
|
|
|
744 |
query->SQL->Text = sql_statement;
|
|
|
745 |
query->ExecSQL();
|
|
|
746 |
|
|
|
747 |
sql_statement="";
|
|
|
748 |
sql_statement.sprintf("INSERT INTO TXNSPEC_STEPS (TESTSCENARIO_NO,NAME,DESCRIPTION,EXPECTED_RESULT) "
|
|
|
749 |
"VALUES (%d,'%s','%s','%s')",
|
|
|
750 |
testscenario_no,
|
|
|
751 |
td_node->name.c_str(),
|
|
|
752 |
ProcessQuotedString(td_node->text1).c_str(),
|
|
|
753 |
ProcessQuotedString(td_node->text2).c_str()
|
|
|
754 |
);
|
|
|
755 |
|
|
|
756 |
query->SQL->Text = sql_statement;
|
|
|
757 |
query->ExecSQL();
|
|
|
758 |
}
|
|
|
759 |
}
|
|
|
760 |
}
|
|
|
761 |
break;
|
|
|
762 |
} // switch
|
|
|
763 |
}
|
|
|
764 |
}
|
|
|
765 |
|
|
|
766 |
//---------------------------------------------------------------------------
|
|
|
767 |
|
|
|
768 |
|
|
|
769 |
|
|
|
770 |
void __fastcall TTestDirectorImportForm::TestScenarioTreeViewChange(
|
|
|
771 |
TObject *Sender, TTreeNode *Node)
|
|
|
772 |
{
|
|
|
773 |
TCursor Save_Cursor = Screen->Cursor;
|
|
|
774 |
Screen->Cursor = crHourGlass; // Show hourglass cursor
|
|
|
775 |
|
|
|
776 |
try
|
|
|
777 |
{
|
|
|
778 |
TestStepMemo->Clear();
|
|
|
779 |
TestStepOutcomeMemo->Clear();
|
|
|
780 |
|
|
|
781 |
TestScenarioMemo->Clear();
|
|
|
782 |
|
|
|
783 |
TestDirectorNode *td_node = (TestDirectorNode *)(Node->Data);
|
|
|
784 |
|
|
|
785 |
if (td_node != NULL)
|
|
|
786 |
{
|
|
|
787 |
TestStepPanel->Caption = td_node->name;
|
|
|
788 |
|
|
|
789 |
TestScenarioMemo->Lines->Text = td_node->text1;
|
|
|
790 |
TestScenarioMemo->WordWrap = wwRightMargin;
|
|
|
791 |
TestScenarioMemo->Update();
|
|
|
792 |
|
|
|
793 |
if (td_node->test_steps.size() == 0)
|
|
|
794 |
{
|
|
|
795 |
LoadTestSteps(td_node);
|
|
|
796 |
}
|
|
|
797 |
|
|
|
798 |
TTreeNode *node = NULL;
|
|
|
799 |
|
|
|
800 |
TestStepTreeView->Items->Clear();
|
|
|
801 |
|
|
|
802 |
node = TestStepTreeView->Items->Add(NULL, "Test Steps");
|
|
|
803 |
node->ImageIndex = 0;
|
|
|
804 |
node->SelectedIndex = 1;
|
|
|
805 |
|
|
|
806 |
DrawSubTree(TestStepTreeView, node, TESTSTEP, td_node->subjectnode);
|
|
|
807 |
|
|
|
808 |
node->Expand(true);
|
|
|
809 |
}
|
|
|
810 |
}
|
|
|
811 |
__finally
|
|
|
812 |
{
|
|
|
813 |
Screen->Cursor = Save_Cursor; // always restore the cursor
|
|
|
814 |
}
|
|
|
815 |
}
|
|
|
816 |
//---------------------------------------------------------------------------
|
|
|
817 |
|
|
|
818 |
void __fastcall TTestDirectorImportForm::TestStepTreeViewChange(
|
|
|
819 |
TObject *Sender, TTreeNode *Node)
|
|
|
820 |
{
|
|
|
821 |
TCursor Save_Cursor = Screen->Cursor;
|
|
|
822 |
Screen->Cursor = crHourGlass; // Show hourglass cursor
|
|
|
823 |
|
|
|
824 |
try
|
|
|
825 |
{
|
|
|
826 |
TestStepMemo->Clear();
|
|
|
827 |
TestStepOutcomeMemo->Clear();
|
|
|
828 |
|
|
|
829 |
TestDirectorNode *td_node = (TestDirectorNode *)(Node->Data);
|
|
|
830 |
|
|
|
831 |
if (td_node != NULL)
|
|
|
832 |
{
|
|
|
833 |
TestStepMemo->Lines->Text = td_node->text1;
|
|
|
834 |
TestStepMemo->WordWrap = wwRightMargin;
|
|
|
835 |
TestStepMemo->Update();
|
|
|
836 |
|
|
|
837 |
TestStepOutcomeMemo->Lines->Text = td_node->text2;
|
|
|
838 |
TestStepOutcomeMemo->WordWrap = wwRightMargin;
|
|
|
839 |
TestStepOutcomeMemo->Update();
|
|
|
840 |
}
|
|
|
841 |
}
|
|
|
842 |
__finally
|
|
|
843 |
{
|
|
|
844 |
Screen->Cursor = Save_Cursor; // always restore the cursor
|
|
|
845 |
}
|
|
|
846 |
}
|
|
|
847 |
//---------------------------------------------------------------------------
|
|
|
848 |
|