WSDL Test Plan

From Eclipsepedia

Revision as of 11:55, 19 September 2008 by Wuamy.ca.ibm.com (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search


WSDL Component Test Plan
WTP 1.5 Final

http://www.eclipse.org//webtools/images/wtplogosmall.jpg

  Task Oriented Tests

Test Case 1 : Start From Scratch - Standalone

  1. Use the New WSDL Wizard to create a new wsdl (alternative) Use New File to create a blank 'wsdl' file ... everything should still work

  2. Select a 'target' WSDL that you can attempt to reproduce. Here's some suggestions but feel free to come up with your own
      Description Where
      PhoneBanking XML Examples Project
      Google Search API link
      Fax link

  3. Using the target WSDL as a guide, utilize the design view to reproduce it. Attempt to use a top down flow since this best simulates how a user would go about building from scratch (e.g. start with the main elements and types and work your way down to the leaf objects. Be sure to open bugs if...
    • you run into quirky problems that make editing feel unnatural
    • you need to go off to the outline or source view to work around problems
    • you hit performance problems that affect your productivity
    • etc.

  4. When you think your WSDL is complete, use the validator to ensure it's valid.
    • Since the editor was used to author the document there should be very few validation problems (if any). If there are some look at these carefully and consider why the editor produced these.
    • some of the validation problems are unavoidable but in general the editor should be fairly good at protecting the users against 'bad' WSDLs
    • if there are problems it's likely that the user will need to use the source view to fix them
    • ensure that all problems can be fixed in the source view and that red squggles work
    • as you fix things in the source view ensure that red squiggle indicators go away
    • ensure that when you flip back to the design view that any source changes are reflected in the view

  5. As a final test open use the 'jst' tools to generate and deploy a skeleton web services for the WSDL

Test Case 2 : Start From Scratch - One Piece of a Larger Project

  1. Repeat Test Case 1 but recreate a WSDL that's uses a muti-file pattern . Here's some examples...
      Name Where
      SpaceWarGame-b XML Examples Project
      PhoneBanking-b XML Examples Project
  2. Be sure to utilize the 'Browse...' function when editing type and element references.
  3. Inspect the WSDL after using 'Browse...' to ensure that the <include> or <import> and the 'xmlns:xxx' gets updated correctly.
  4. Inspect the source view after using 'Browse...' to ensure the type or element reference is not red squiggled (and muck with it to make sure the squiggle does show when expected)



Test Case 3 : Visualize and Browse a Large/Complex WSDL

  1. Select a WSDL that we want to view.
  2. Use the design view to naviagate the WSDL and open referenced XML Schemas. Ensure all of the following work...
    • click on the 'arrow' beside an element or complex type in the portType ... ensure a schema editor is opened and the 'clicked' object is shown
    • after following a chain of referenes, ensure the 'back arrow' button allows you to reverse back up the chain
    • expand the binding objects to ensure they layout correctly in their 'ruler-ish' form


  3. Use the source view to naviage thru the WSDLs and XSDs. Ensure all of the following work...
    • hold down crtl to see the hyperlinks as you mouse over them, ensure hyperlins appear for all 'references'
    • ctrl-lick or F3 on hypelinks to ensure 'open on' works
    • after following a chain of referenes, ensure the 'back arrow' button allows you to reverse back up the chain

  4. Navigate thru the WSDLs and XSDs using both the design and source view (flipping between 'em) and ensure both modes of navigation work together nicely.

  5. Use the outline view in conjuction and ensure it interacts as expected with the source and design view

  6. From the source, design and outline views. Use the 'references->project' or 'references->workspace' for several components (portTypes, bindings, types, elements etc.) to understand how components are reused.


  Function Oriented Tests

New WSDL Wizard

  1. Try the various options available on the New WSDL file options page
    • option to create WSDL Skeleton
    • SOAP...document literal, rpc literal, rpc encoded
    • HTTP...HTTP GET, HTTP POST

design View

  1. Top Level View
    • Actions to add/remove/rename components
    • Open Schema/WSDL Imports
    • Imported WSDL components should appear but not be editable
    • Inline Schemas located in the 'top level' view should allow drill down
    • Connecting lines should appear to show WSDL component relationships
  2. In Drilled Down View of Schema Components...
    • Test that menus show proper content for different objects
    • Test Drag and Drop
    • Ensure deleting the 'top level' component pops you back to the top view
    • Test selection of 'simple type' icon within an element declaration
    • Content that originates via derivation should be demarked with dotted box

Outline View

  1. Selection from Outline view should select the corresponding object in the design view
  2. Context menu for a particular component should be the same in both the design and Outline views

Source View

  1. Test editing features
    • Add WSDL Components
    • Delete from source
    • Copy and paste
    • Test for invalid content
  2. Test 'standard' xml content assist support (see xml source editor) for adding WSDL and schema elements

Properties View

  1. Properties view should be available for all selected schema components
  2. Test that view can't be 'broken'... should always have 'good' content
  3. Imported WSDL components should not be editable through the properties
  4. Renaming components should 'auto refactor' within source file (references to renamed component should be updated)
  5. Update documentation for various components

Set Existing Component Dialog

  1. Set Existing Component Dialog launched via the context menu or properties
    • Port
    • Binding
    • Input
    • Output
    • Fault
    • Part
  2. Adjust the search scope. The available components displayed should be updated
  3. The text filter located at the top of the dialog is used to filter the available types

Generate Binding Content

  1. Click on a Binding and select "Generate Binding Content..." from the context menu. Select the "Overwrite existing binding information option". Ensure the proper binding information is generated
  2. Test out the different Binding options (SOAP, HTTP, etc...)

Smart Renaming

  1. Test smart renaming on the following Components
    • Operation
    • Fault
    • Message
    • Part
  2. Renaming one of the above elements should also rename it's 'children' if the 'child' has a generated name. For example, "MyOperationName" (Operation) --> Input --> "MyOperationNameRequest" (Message) --> "MyOperationNameRequest" (Part) A rename on Operation to "NewOp" will cause the following result: "newOpName" (Operation) --> Input --> "newOpNameRequest" (Message) --> "newOpNameRequest" (Part)
  3. The same pattern follows when renaming a Fault, Message, and Part
  4. Initiate renaming via the context menu or the properties view

Imports

  1. WSDL imports
    • Test adding them via outline/properties view and via source view
    • Verify imported objects show up in design view (may need to close and reopen editor
    • Verify new components are available in the 'set type' dialog
    • Verify import shows up in outline view
  2. XSD imports
    • Test adding them via the 'set type' dialog will add xsd import to the wsdl
    • Verify new components are available in the 'set type' dialog
    • Verify xsd:import and wsdl:import cannot be interchanged and using one instead of the other will result in validaiton error
  3. Unused imports
    • Check preferences under Web Services->WSDL Files
    • Test that unused WSDL and XSD imports are removed

General

  1. Test the various menu actions available for different components
  2. Reload dependancies action from the WSDL Editor menu bar
  3. Test 'Edit Namespaces...' action
  4. Menu actions for 'categories' should only provide actions appicable to that particular category (e.g. element category should have 'Add Element')
  5. Undo/Redo
  6. View selection synchronization
  7. Editing synchronization : source -> model (perform source changes below and ensure model is intact)
    • cut and paste sections to/from source view
    • make various random changes in the souce view and then undo
    • delete and restore component declarations from source and ensure references are updated
    • change a file locally and refresh
  8. Editing synchronization : model -> source (perform designical changes below and ensure source is intact)
    • make random changes to the WSDL model via the graphical views
    • make various changes in the souce view and then undo
  9. F3 support
    • F3 on component references should cause selection to 'jump' to referenced component
    • F3 on imports should open the imported schema or WSDL


  Performance Tests
an id attribute

Performance Test 1 : Validation

  1. Perform a 'full' validation of a large project (see list of project in Usage Test 2)
  2. Open an applicable artifact in the editor and type in the source page to ensure 'as you type' validation is responive
  3. Test validation on projects that contain references to external URLs
  4. Validate in disconnected mode (no internet access)
  5. Run JUnit validation performance tests


Performance Test 2 : Opening the Editor

  1. Test how many editors can be opened at once
    • Import a large project into the workspace with many applicable artifacts
    • Open an editor for each artifact until you run out of memory (hint : use multi-select and open)
  2. Test how how quickly an editor opens
    • Use a very large artifact
    • Use an artifact that pulls in lots of other artifacts

Performance Test 3 : Editing Responsiveness

  1. Add and Remove various objects
    • from the design view
    • from the outline
    • from the source view
  2. Typing in the source view
    • rename an element (type quickly on the keyboard)
  3. Open on
    • from the design view
    • from the source view

Performance Test 4 : Search and Refactoring

  • Using a mediumm or large sized schema project
    • select a component and test 'refereces->workspace'
    • select a component and refactor->rename (with preview and without)
    • record timings for both 'cold' and 'warm' starts