1
2
3
4
5
6
7
8
9
10
11
12
13 package com.eviware.soapui.impl.wsdl.teststeps;
14
15 import java.beans.PropertyChangeEvent;
16 import java.beans.PropertyChangeListener;
17 import java.util.ArrayList;
18 import java.util.Collection;
19 import java.util.Collections;
20 import java.util.List;
21 import java.util.Map;
22
23 import javax.swing.ImageIcon;
24
25 import org.apache.log4j.Logger;
26
27 import com.eviware.soapui.config.RequestStepConfig;
28 import com.eviware.soapui.config.TestStepConfig;
29 import com.eviware.soapui.impl.support.http.HttpRequestTestStep;
30 import com.eviware.soapui.impl.wsdl.AbstractWsdlModelItem;
31 import com.eviware.soapui.impl.wsdl.WsdlInterface;
32 import com.eviware.soapui.impl.wsdl.WsdlOperation;
33 import com.eviware.soapui.impl.wsdl.WsdlProject;
34 import com.eviware.soapui.impl.wsdl.WsdlRequest;
35 import com.eviware.soapui.impl.wsdl.WsdlSubmit;
36 import com.eviware.soapui.impl.wsdl.submit.transports.http.WsdlResponse;
37 import com.eviware.soapui.impl.wsdl.support.assertions.AssertedXPathsContainer;
38 import com.eviware.soapui.impl.wsdl.testcase.WsdlTestCase;
39 import com.eviware.soapui.impl.wsdl.testcase.WsdlTestRunContext;
40 import com.eviware.soapui.impl.wsdl.teststeps.assertions.TestAssertionRegistry.AssertableType;
41 import com.eviware.soapui.model.ModelItem;
42 import com.eviware.soapui.model.iface.Interface;
43 import com.eviware.soapui.model.iface.Operation;
44 import com.eviware.soapui.model.iface.Submit;
45 import com.eviware.soapui.model.iface.Request.SubmitException;
46 import com.eviware.soapui.model.project.Project;
47 import com.eviware.soapui.model.propertyexpansion.PropertyExpander;
48 import com.eviware.soapui.model.propertyexpansion.PropertyExpansion;
49 import com.eviware.soapui.model.propertyexpansion.PropertyExpansionContainer;
50 import com.eviware.soapui.model.propertyexpansion.PropertyExpansionsResult;
51 import com.eviware.soapui.model.support.InterfaceListenerAdapter;
52 import com.eviware.soapui.model.support.ModelSupport;
53 import com.eviware.soapui.model.support.ProjectListenerAdapter;
54 import com.eviware.soapui.model.support.TestStepBeanProperty;
55 import com.eviware.soapui.model.testsuite.Assertable;
56 import com.eviware.soapui.model.testsuite.AssertionError;
57 import com.eviware.soapui.model.testsuite.AssertionsListener;
58 import com.eviware.soapui.model.testsuite.OperationTestStep;
59 import com.eviware.soapui.model.testsuite.TestAssertion;
60 import com.eviware.soapui.model.testsuite.TestCaseRunContext;
61 import com.eviware.soapui.model.testsuite.TestCaseRunner;
62 import com.eviware.soapui.model.testsuite.TestStep;
63 import com.eviware.soapui.model.testsuite.TestStepResult;
64 import com.eviware.soapui.model.testsuite.TestStepResult.TestStepStatus;
65 import com.eviware.soapui.support.resolver.ChangeOperationResolver;
66 import com.eviware.soapui.support.resolver.ImportInterfaceResolver;
67 import com.eviware.soapui.support.resolver.RemoveTestStepResolver;
68 import com.eviware.soapui.support.resolver.ResolveContext;
69 import com.eviware.soapui.support.resolver.ResolveContext.PathToResolve;
70 import com.eviware.soapui.support.types.StringToStringMap;
71
72 /***
73 * WsdlTestStep that executes a WsdlTestRequest
74 *
75 * @author Ole.Matzura
76 */
77
78 public class WsdlTestRequestStep extends WsdlTestStepWithProperties implements OperationTestStep,
79 PropertyChangeListener, PropertyExpansionContainer, Assertable, HttpRequestTestStep
80 {
81 private final static Logger log = Logger.getLogger( WsdlTestRequestStep.class );
82 private RequestStepConfig requestStepConfig;
83 private WsdlTestRequest testRequest;
84 private WsdlOperation wsdlOperation;
85 private final InternalProjectListener projectListener = new InternalProjectListener();
86 private final InternalInterfaceListener interfaceListener = new InternalInterfaceListener();
87 private WsdlSubmit<WsdlRequest> submit;
88
89 public WsdlTestRequestStep( WsdlTestCase testCase, TestStepConfig config, boolean forLoadTest )
90 {
91 super( testCase, config, true, forLoadTest );
92
93 if( getConfig().getConfig() != null )
94 {
95 requestStepConfig = ( RequestStepConfig )getConfig().getConfig().changeType( RequestStepConfig.type );
96
97 wsdlOperation = findWsdlOperation();
98 if( wsdlOperation == null )
99 {
100 log.error( "Could not find operation [" + requestStepConfig.getOperation() + "] in interface ["
101 + requestStepConfig.getInterface() + "] for test request [" + getName() + "] in TestCase ["
102 + getTestCase().getTestSuite().getName() + "/" + getTestCase().getName() + "]" );
103
104 setDisabled( true );
105 }
106 else
107 {
108 initTestRequest( config, forLoadTest );
109 }
110 }
111 else
112 {
113 requestStepConfig = ( RequestStepConfig )getConfig().addNewConfig().changeType( RequestStepConfig.type );
114 }
115
116
117 if( testRequest != null )
118 {
119 initRequestProperties();
120 }
121 }
122
123 private void initRequestProperties()
124 {
125 addProperty( new TestStepBeanProperty( "Endpoint", false, testRequest, "endpoint", this ) );
126 addProperty( new TestStepBeanProperty( "Username", false, testRequest, "username", this ) );
127 addProperty( new TestStepBeanProperty( "Password", false, testRequest, "password", this ) );
128 addProperty( new TestStepBeanProperty( "Domain", false, testRequest, "domain", this ) );
129 addProperty( new TestStepBeanProperty( "Request", false, testRequest, "requestContent", this )
130 {
131 @Override
132 public String getDefaultValue()
133 {
134 return getOperation().createRequest( true );
135 }
136 } );
137 addProperty( new TestStepBeanProperty( "Response", true, testRequest, "responseContent", this )
138 {
139 @Override
140 public String getDefaultValue()
141 {
142 return getOperation().createResponse( true );
143 }
144 } );
145 }
146
147 private void initTestRequest( TestStepConfig config, boolean forLoadTest )
148 {
149 if( !forLoadTest )
150 {
151 wsdlOperation.getInterface().getProject().addProjectListener( projectListener );
152 wsdlOperation.getInterface().addInterfaceListener( interfaceListener );
153
154
155
156 wsdlOperation.getInterface().addPropertyChangeListener( this );
157 wsdlOperation.addPropertyChangeListener( this );
158 }
159
160 testRequest = new WsdlTestRequest( wsdlOperation, requestStepConfig.getRequest(), this, forLoadTest );
161 testRequest.addPropertyChangeListener( this );
162
163 if( config.isSetName() )
164 testRequest.setName( config.getName() );
165 else
166 config.setName( testRequest.getName() );
167 }
168
169 @Override
170 public WsdlTestStep clone( WsdlTestCase targetTestCase, String name )
171 {
172 beforeSave();
173
174 TestStepConfig config = ( TestStepConfig )getConfig().copy();
175 RequestStepConfig stepConfig = ( RequestStepConfig )config.getConfig().changeType( RequestStepConfig.type );
176
177 while( stepConfig.getRequest().sizeOfAttachmentArray() > 0 )
178 stepConfig.getRequest().removeAttachment( 0 );
179
180 config.setName( name );
181 stepConfig.getRequest().setName( name );
182
183 WsdlTestRequestStep result = ( WsdlTestRequestStep )targetTestCase.addTestStep( config );
184 testRequest.copyAttachmentsTo( result.getTestRequest() );
185
186 return result;
187 }
188
189 private WsdlOperation findWsdlOperation()
190 {
191 WsdlTestCase testCase = getTestCase();
192 if( testCase == null || testCase.getTestSuite() == null )
193 return null;
194
195 Project project = testCase.getTestSuite().getProject();
196 WsdlOperation operation = null;
197 for( int c = 0; c < project.getInterfaceCount(); c++ )
198 {
199 if( project.getInterfaceAt( c ).getName().equals( requestStepConfig.getInterface() ) )
200 {
201 WsdlInterface iface = ( WsdlInterface )project.getInterfaceAt( c );
202 for( int i = 0; i < iface.getOperationCount(); i++ )
203 {
204 if( iface.getOperationAt( i ).getName().equals( requestStepConfig.getOperation() ) )
205 {
206 operation = iface.getOperationAt( i );
207 break;
208 }
209 }
210
211 if( operation != null )
212 break;
213 }
214 }
215 return operation;
216 }
217
218 public String getInterfaceName()
219 {
220 return requestStepConfig.getInterface();
221 }
222
223 public String getOperationName()
224 {
225 return requestStepConfig.getOperation();
226 }
227
228 @Override
229 public void release()
230 {
231 super.release();
232
233 if( wsdlOperation == null )
234 wsdlOperation = findWsdlOperation();
235
236 if( wsdlOperation != null )
237 {
238 wsdlOperation.removePropertyChangeListener( this );
239 wsdlOperation.getInterface().getProject().removeProjectListener( projectListener );
240 wsdlOperation.getInterface().removeInterfaceListener( interfaceListener );
241 wsdlOperation.getInterface().removePropertyChangeListener( this );
242 }
243
244
245 if( testRequest != null )
246 {
247 testRequest.removePropertyChangeListener( this );
248 testRequest.release();
249 }
250 }
251
252 @Override
253 public void resetConfigOnMove( TestStepConfig config )
254 {
255 super.resetConfigOnMove( config );
256
257 requestStepConfig = ( RequestStepConfig )config.getConfig().changeType( RequestStepConfig.type );
258 testRequest.updateConfig( requestStepConfig.getRequest() );
259 }
260
261 @Override
262 public ImageIcon getIcon()
263 {
264 return testRequest == null ? null : testRequest.getIcon();
265 }
266
267 public WsdlTestRequest getTestRequest()
268 {
269 return testRequest;
270 }
271
272 @Override
273 public void setName( String name )
274 {
275 super.setName( name );
276 testRequest.setName( name );
277 }
278
279 public void propertyChange( PropertyChangeEvent arg0 )
280 {
281 if( arg0.getSource() == wsdlOperation )
282 {
283 if( arg0.getPropertyName().equals( Operation.NAME_PROPERTY ) )
284 {
285 requestStepConfig.setOperation( ( String )arg0.getNewValue() );
286 }
287 }
288 else if( arg0.getSource() == wsdlOperation.getInterface() )
289 {
290 if( arg0.getPropertyName().equals( Interface.NAME_PROPERTY ) )
291 {
292 requestStepConfig.setInterface( ( String )arg0.getNewValue() );
293 }
294 }
295 else if( arg0.getPropertyName().equals( TestAssertion.CONFIGURATION_PROPERTY )
296 || arg0.getPropertyName().equals( TestAssertion.DISABLED_PROPERTY ) )
297 {
298 if( getTestRequest().getResponse() != null )
299 {
300 getTestRequest().assertResponse( new WsdlTestRunContext( this ) );
301 }
302 }
303 else
304 {
305 if( arg0.getSource() == testRequest && arg0.getPropertyName().equals( WsdlTestRequest.NAME_PROPERTY ) )
306 {
307 if( !super.getName().equals( ( String )arg0.getNewValue() ) )
308 super.setName( ( String )arg0.getNewValue() );
309 }
310
311 notifyPropertyChanged( arg0.getPropertyName(), arg0.getOldValue(), arg0.getNewValue() );
312 }
313 }
314
315 public TestStepResult run( TestCaseRunner runner, TestCaseRunContext runContext )
316 {
317 WsdlTestRequestStepResult testStepResult = new WsdlTestRequestStepResult( this );
318 testStepResult.startTimer();
319 runContext.setProperty( AssertedXPathsContainer.ASSERTEDXPATHSCONTAINER_PROPERTY, testStepResult );
320
321 try
322 {
323 submit = testRequest.submit( runContext, false );
324 WsdlResponse response = ( WsdlResponse )submit.getResponse();
325
326 if( submit.getStatus() != Submit.Status.CANCELED )
327 {
328 if( submit.getStatus() == Submit.Status.ERROR )
329 {
330 testStepResult.setStatus( TestStepStatus.FAILED );
331 testStepResult.addMessage( submit.getError().toString() );
332
333
334 testRequest.setResponse( null, runContext );
335 }
336 else if( response == null )
337 {
338 testStepResult.setStatus( TestStepStatus.FAILED );
339 testStepResult.addMessage( "Request is missing response" );
340
341 testRequest.setResponse( null, runContext );
342 }
343 else
344 {
345 runContext.setProperty( AssertedXPathsContainer.ASSERTEDXPATHSCONTAINER_PROPERTY, testStepResult );
346 testRequest.setResponse( response, runContext );
347
348 testStepResult.setTimeTaken( response.getTimeTaken() );
349 testStepResult.setSize( response.getContentLength() );
350
351 switch( testRequest.getAssertionStatus() )
352 {
353 case FAILED :
354 testStepResult.setStatus( TestStepStatus.FAILED );
355 break;
356 case VALID :
357 testStepResult.setStatus( TestStepStatus.OK );
358 break;
359 case UNKNOWN :
360 testStepResult.setStatus( TestStepStatus.UNKNOWN );
361 break;
362 }
363
364 testStepResult.setResponse( response, testStepResult.getStatus() != TestStepStatus.FAILED );
365 }
366 }
367 else
368 {
369 testStepResult.setStatus( TestStepStatus.CANCELED );
370 testStepResult.addMessage( "Request was canceled" );
371 }
372
373 if( response != null )
374 testStepResult.setRequestContent( response.getRequestContent(), testStepResult.getStatus() != TestStepStatus.FAILED );
375 else
376 testStepResult.setRequestContent( testRequest.getRequestContent(), testStepResult.getStatus() != TestStepStatus.FAILED );
377 testStepResult.stopTimer();
378 }
379 catch( SubmitException e )
380 {
381 testStepResult.setStatus( TestStepStatus.FAILED );
382 testStepResult.addMessage( "SubmitException: " + e );
383 testStepResult.stopTimer();
384 }
385 finally
386 {
387 submit = null;
388 }
389
390 testStepResult.setDomain( PropertyExpander.expandProperties( runContext, testRequest.getDomain() ) );
391 testStepResult.setUsername( PropertyExpander.expandProperties( runContext, testRequest.getUsername() ) );
392 testStepResult.setPassword( PropertyExpander.expandProperties( runContext, testRequest.getPassword() ) );
393 testStepResult.setEndpoint( PropertyExpander.expandProperties( runContext, testRequest.getEndpoint() ) );
394 testStepResult.setEncoding( PropertyExpander.expandProperties( runContext, testRequest.getEncoding() ) );
395
396 if( testStepResult.getStatus() != TestStepStatus.CANCELED )
397 {
398 AssertionStatus assertionStatus = testRequest.getAssertionStatus();
399 switch( assertionStatus )
400 {
401 case FAILED :
402 {
403 testStepResult.setStatus( TestStepStatus.FAILED );
404 if( getAssertionCount() == 0 )
405 {
406 testStepResult.addMessage( "Invalid/empty response" );
407 }
408 else
409 for( int c = 0; c < getAssertionCount(); c++ )
410 {
411 AssertionError[] errors = getAssertionAt( c ).getErrors();
412 if( errors != null )
413 {
414 for( AssertionError error : errors )
415 {
416 testStepResult.addMessage( error.getMessage() );
417 }
418 }
419 }
420
421 break;
422 }
423
424 }
425 }
426
427
428
429
430 return testStepResult;
431 }
432
433 public WsdlMessageAssertion getAssertionAt( int index )
434 {
435 return testRequest.getAssertionAt( index );
436 }
437
438 public int getAssertionCount()
439 {
440 return testRequest == null ? 0 : testRequest.getAssertionCount();
441 }
442
443 public WsdlTestRequest getHttpRequest()
444 {
445 return testRequest;
446 }
447
448 public class InternalProjectListener extends ProjectListenerAdapter
449 {
450 @Override
451 public void interfaceRemoved( Interface iface )
452 {
453 if( wsdlOperation != null && wsdlOperation.getInterface().equals( iface ) )
454 {
455 log.debug( "Removing test step due to removed interface" );
456 ( getTestCase() ).removeTestStep( WsdlTestRequestStep.this );
457 }
458 }
459 }
460
461 public class InternalInterfaceListener extends InterfaceListenerAdapter
462 {
463 @Override
464 public void operationRemoved( Operation operation )
465 {
466 if( operation == wsdlOperation )
467 {
468 log.debug( "Removing test step due to removed operation" );
469 ( getTestCase() ).removeTestStep( WsdlTestRequestStep.this );
470 }
471 }
472
473 @Override
474 public void operationUpdated( Operation operation )
475 {
476 if( operation == wsdlOperation )
477 {
478 requestStepConfig.setOperation( operation.getName() );
479 }
480 }
481 }
482
483 @Override
484 public boolean cancel()
485 {
486 if( submit == null )
487 return false;
488
489 submit.cancel();
490
491 return true;
492 }
493
494 @Override
495 public Collection<Interface> getRequiredInterfaces()
496 {
497 ArrayList<Interface> result = new ArrayList<Interface>();
498 result.add( findWsdlOperation().getInterface() );
499 return result;
500 }
501
502 public String getDefaultSourcePropertyName()
503 {
504 return "Response";
505 }
506
507 public String getDefaultTargetPropertyName()
508 {
509 return "Request";
510 }
511
512 @Override
513 public boolean dependsOn( AbstractWsdlModelItem<?> modelItem )
514 {
515 if( modelItem instanceof Interface && testRequest.getOperation().getInterface() == modelItem )
516 {
517 return true;
518 }
519 else if( modelItem instanceof Operation && testRequest.getOperation() == modelItem )
520 {
521 return true;
522 }
523
524 return false;
525 }
526
527 @Override
528 public void beforeSave()
529 {
530 super.beforeSave();
531
532 if( testRequest != null )
533 testRequest.beforeSave();
534 }
535
536 @Override
537 public String getDescription()
538 {
539 return testRequest == null ? "<missing>" : testRequest.getDescription();
540 }
541
542 @Override
543 public void setDescription( String description )
544 {
545 if( testRequest != null )
546 testRequest.setDescription( description );
547 }
548
549 public void setOperation( WsdlOperation operation )
550 {
551 if( wsdlOperation == operation )
552 return;
553
554 WsdlOperation oldOperation = wsdlOperation;
555 wsdlOperation = operation;
556 requestStepConfig.setInterface( operation.getInterface().getName() );
557 requestStepConfig.setOperation( operation.getName() );
558
559 if( oldOperation != null )
560 oldOperation.removePropertyChangeListener( this );
561
562 wsdlOperation.addPropertyChangeListener( this );
563
564 initTestRequest( this.getConfig(), false );
565 testRequest.setOperation( wsdlOperation );
566 }
567
568 @SuppressWarnings( "unchecked" )
569 @Override
570 public List<? extends ModelItem> getChildren()
571 {
572 return testRequest == null ? Collections.EMPTY_LIST : testRequest.getAssertionList();
573 }
574
575 public PropertyExpansion[] getPropertyExpansions()
576 {
577 if( testRequest == null )
578 return new PropertyExpansion[0];
579
580 PropertyExpansionsResult result = new PropertyExpansionsResult( this, testRequest );
581
582 result.extractAndAddAll( "requestContent" );
583 result.extractAndAddAll( "endpoint" );
584 result.extractAndAddAll( "username" );
585 result.extractAndAddAll( "password" );
586 result.extractAndAddAll( "domain" );
587
588 StringToStringMap requestHeaders = testRequest.getRequestHeaders();
589 for( String key : requestHeaders.keySet() )
590 {
591 result.extractAndAddAll( new RequestHeaderHolder( requestHeaders, key ), "value" );
592 }
593
594 testRequest.addWsaPropertyExpansions( result, testRequest.getWsaConfig(), this );
595 return result.toArray( new PropertyExpansion[result.size()] );
596 }
597
598 public class RequestHeaderHolder
599 {
600 private final StringToStringMap valueMap;
601 private final String key;
602
603 public RequestHeaderHolder( StringToStringMap valueMap, String key )
604 {
605 this.valueMap = valueMap;
606 this.key = key;
607 }
608
609 public String getValue()
610 {
611 return valueMap.get( key );
612 }
613
614 public void setValue( String value )
615 {
616 valueMap.put( key, value );
617 testRequest.setRequestHeaders( valueMap );
618 }
619 }
620
621 public TestAssertion addAssertion( String type )
622 {
623 WsdlMessageAssertion result = testRequest.addAssertion( type );
624 return result;
625 }
626
627 public void addAssertionsListener( AssertionsListener listener )
628 {
629 testRequest.addAssertionsListener( listener );
630 }
631
632 public TestAssertion cloneAssertion( TestAssertion source, String name )
633 {
634 return testRequest.cloneAssertion( source, name );
635 }
636
637 public String getAssertableContent()
638 {
639 return testRequest.getAssertableContent();
640 }
641
642 public AssertableType getAssertableType()
643 {
644 return testRequest.getAssertableType();
645 }
646
647 public TestAssertion getAssertionByName( String name )
648 {
649 return testRequest.getAssertionByName( name );
650 }
651
652 public List<TestAssertion> getAssertionList()
653 {
654 return testRequest.getAssertionList();
655 }
656
657 public AssertionStatus getAssertionStatus()
658 {
659 return testRequest.getAssertionStatus();
660 }
661
662 public Interface getInterface()
663 {
664 return getOperation().getInterface();
665 }
666
667 public WsdlOperation getOperation()
668 {
669 return wsdlOperation;
670 }
671
672 public TestStep getTestStep()
673 {
674 return this;
675 }
676
677 public void removeAssertion( TestAssertion assertion )
678 {
679 testRequest.removeAssertion( assertion );
680 }
681
682 public TestAssertion moveAssertion( int ix, int whereTo )
683 {
684 return testRequest.moveAssertion( ix, whereTo );
685 }
686
687 public void removeAssertionsListener( AssertionsListener listener )
688 {
689 testRequest.removeAssertionsListener( listener );
690 }
691
692 public Map<String, TestAssertion> getAssertions()
693 {
694 return testRequest.getAssertions();
695 }
696
697 @Override
698 public void prepare( TestCaseRunner testRunner, TestCaseRunContext testRunContext ) throws Exception
699 {
700 super.prepare( testRunner, testRunContext );
701
702 testRequest.setResponse( null, testRunContext );
703
704 for( TestAssertion assertion : testRequest.getAssertionList() )
705 {
706 assertion.prepare( testRunner, testRunContext );
707 }
708 }
709
710 public String getDefaultAssertableContent()
711 {
712 return testRequest.getDefaultAssertableContent();
713 }
714
715 @SuppressWarnings( "unchecked" )
716 public void resolve( ResolveContext<?> context )
717 {
718 super.resolve( context );
719
720 if( wsdlOperation == null )
721 {
722
723 if( context.hasThisModelItem( this, "Missing SOAP Operation in Project", requestStepConfig.getInterface()
724 + "/" + requestStepConfig.getOperation() ) )
725 return;
726
727 context.addPathToResolve( this, "Missing SOAP Operation in Project",
728 requestStepConfig.getInterface() + "/" + requestStepConfig.getOperation() ).addResolvers(
729 new RemoveTestStepResolver( this ), new ImportInterfaceResolver( this )
730 {
731
732 @Override
733 protected boolean update()
734 {
735 wsdlOperation = findWsdlOperation();
736 if( wsdlOperation == null )
737 return false;
738
739 initTestRequest( getConfig(), false );
740 initRequestProperties();
741 setDisabled( false );
742 return true;
743 }
744 }, new ChangeOperationResolver( this, "Operation" )
745 {
746
747 @Override
748 public boolean update()
749 {
750 WsdlOperation wsdlOperation = ( WsdlOperation )getSelectedOperation();
751 if( wsdlOperation == null )
752 return false;
753
754 setOperation( wsdlOperation );
755 initTestRequest( getConfig(), false );
756 initRequestProperties();
757 setDisabled( false );
758 return true;
759 }
760
761 protected Interface[] getInterfaces( WsdlProject project )
762 {
763 List<WsdlInterface> interfaces = ModelSupport.getChildren( project, WsdlInterface.class );
764 return interfaces.toArray( new Interface[interfaces.size()] );
765
766 }
767
768 } );
769 }
770 else
771 {
772 testRequest.resolve( context );
773 if( context.hasThisModelItem( this, "Missing SOAP Operation in Project", requestStepConfig.getInterface()
774 + "/" + requestStepConfig.getOperation() ) )
775 {
776 PathToResolve path = context.getPath( this, "Missing SOAP Operation in Project", requestStepConfig
777 .getInterface()
778 + "/" + requestStepConfig.getOperation() );
779 path.setSolved( true );
780 }
781 }
782 }
783
784 }