1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
/*******************************************************************************
* Copyright (c) 2002-2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM - Initial API and implementation
*******************************************************************************/
package org.eclipse.wst.wsi.internal.core.profile.validator.impl.wsdl;
import java.util.Iterator;
import java.util.List;
import javax.wsdl.Types;
import javax.wsdl.extensions.ExtensibilityElement;
import javax.wsdl.extensions.UnknownExtensibilityElement;
import org.eclipse.wst.wsi.internal.core.WSIException;
import org.eclipse.wst.wsi.internal.core.WSITag;
import org.eclipse.wst.wsi.internal.core.profile.TestAssertion;
import org.eclipse.wst.wsi.internal.core.profile.validator.EntryContext;
import org.eclipse.wst.wsi.internal.core.profile.validator.impl.AssertionProcess;
import org.eclipse.wst.wsi.internal.core.report.AssertionResult;
import org.eclipse.wst.wsi.internal.core.util.ErrorList;
import org.eclipse.wst.wsi.internal.core.xml.XMLUtils;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
/**
* BP2107.
* <context>For a candidate wsdl:types element containing an xsd:schema element</context>
* <assertionDescription>The xsd:schema element contains a targetNamespace attribute with a valid and non-null value unless the xsd:schema element has xsd:import and/or xsd:annotation as its only child element(s).</assertionDescription>
*/
public class BP2107 extends AssertionProcess implements WSITag
{
private final WSDLValidatorImpl validator;
/**
* @param WSDLValidatorImpl
*/
public BP2107(WSDLValidatorImpl impl)
{
super(impl);
this.validator = impl;
}
private boolean schemaFound = false;
private ErrorList errors = new ErrorList();
private String context;
/*
* Validates the test assertion.
* @see org.wsi.test.profile.validator.impl.BaseValidatorImpl.AssertionProcess#validate(org.wsi.test.profile.TestAssertion, org.wsi.test.profile.validator.EntryContext)
*/
public AssertionResult validate(
TestAssertion testAssertion,
EntryContext entryContext)
throws WSIException
{
result = AssertionResult.RESULT_FAILED;
Types t = (Types) entryContext.getEntry().getEntryDetail();
List exts = t.getExtensibilityElements();
if (exts != null)
{
context =
entryContext.getWSDLDocument().getDefinitions().getDocumentBaseURI();
Iterator it = exts.iterator();
while (it.hasNext())
{
ExtensibilityElement el = (ExtensibilityElement) it.next();
if (el instanceof UnknownExtensibilityElement)
searchForSchema(((UnknownExtensibilityElement) el).getElement());
}
}
// context = entryContext.getWSDLDocument().getDefinitions().getDocumentBaseURI();
// processWSDL(entryContext.getWSDLDocument().getFilename());
if (!errors.isEmpty())
{
result = AssertionResult.RESULT_FAILED;
failureDetail = this.validator.createFailureDetail(errors.toString(), entryContext);
}
else if (!schemaFound)
result = AssertionResult.RESULT_NOT_APPLICABLE;
else
result = AssertionResult.RESULT_PASSED;
return validator.createAssertionResult(testAssertion, result, failureDetail);
}
/*
* Check node schema or load schema from inmport if it exists and process it.
* @param n - node
*/
private void searchForSchema(Node n)
{
while (n != null)
{
// searches for xsd:import element
if (Node.ELEMENT_NODE == n.getNodeType())
{
// if xsd:schema element is found -> process schema
if (XMLUtils.equals(n, ELEM_XSD_SCHEMA))
{
schemaFound = true;
processSchema(n, null);
}
else
{
// if xsd:import element is found -> load schema and process schema
//if (XMLUtils.equals(n, ELEM_XSD_IMPORT))
// loadSchema(n);
//else
// else iterate element recursively
searchForSchema(n.getFirstChild());
}
}
n = n.getNextSibling();
}
}
/*
* Load schema and process it.
* @param importNode - xsd:import element
*/
private void loadSchema(Node importNode)
{
Element im = (Element) importNode;
Attr schemaLocation = XMLUtils.getAttribute(im, ATTR_XSD_SCHEMALOCATION);
// try to parse imported XSD
if (schemaLocation != null && schemaLocation.getValue() != null)
try
{
// if any error or root element is not XSD schema -> error
Document schema =
validator.parseXMLDocumentURL(schemaLocation.getValue(), context);
if (XMLUtils.equals(schema.getDocumentElement(), ELEM_XSD_SCHEMA))
{
Attr a = XMLUtils.getAttribute(im, ATTR_XSD_NAMESPACE);
String namespace = (a != null) ? a.getValue() : "";
processSchema(schema.getDocumentElement(), namespace);
}
}
catch (Throwable t)
{
// nothing. it's not a schema
}
}
/*
* Create falure report if it's not correspons assertion description.
* @param schema - xsd:schema
* @param namespace - namespace of schema
*/
private void processSchema(Node schema, String namespace)
{
Attr a =
XMLUtils.getAttribute((Element) schema, ATTR_XSD_TARGETNAMESPACE);
String targetNamespace = (a != null) ? a.getValue() : null;
Node n = schema.getFirstChild();
// !! we suppose that xsd:import element is occured only within xsd:schema element
boolean containsOnlyImportAndAnnotation = true;
while (n != null)
{
if (n.getNodeType() == Node.ELEMENT_NODE)
{
containsOnlyImportAndAnnotation
&= (XMLUtils.equals(n, ELEM_XSD_IMPORT)
|| XMLUtils.equals(n, ELEM_XSD_ANNOTATION));
}
//if (Node.ELEMENT_NODE == n.getNodeType() && XMLUtils.equals(n, ELEM_XSD_IMPORT))
// loadSchema(n);
n = n.getNextSibling();
}
// If the target namespace is not set and there are elements in addition to import and annotation, then error
if ((targetNamespace == null || targetNamespace.length() == 0)
&& (!containsOnlyImportAndAnnotation))
{
errors.add(targetNamespace, XMLUtils.serialize((Element) schema));
}
if (namespace != null && !namespace.equals(targetNamespace))
{
errors.add(namespace, XMLUtils.serialize((Element) schema));
}
}
}
|
