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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.tuscany.sca.vtest.assembly.component;
import junit.framework.Assert;
import org.apache.tuscany.sca.vtest.utilities.ServiceFinder;
import org.junit.Ignore;
import org.junit.Test;
import org.osoa.sca.ServiceRuntimeException;
/**
*
*/
public class ComponentTestCase {
private void initDomain(String compositePath) {
System.out.println("Setting up");
ServiceFinder.init(compositePath);
}
private void cleanupDomain() {
System.out.println("Cleaning up");
ServiceFinder.cleanup();
}
/**
* Lines 92-96:
* <p>
* Components are configured instances of implementations. Components
* provide and consume services. More than one component can use and
* configure the same implementation, where each component configures the
* implementation differently.
*/
@Test
public void components1() throws Exception {
initDomain("component.composite");
AService service = ServiceFinder.getService(AService.class, "AComponent/AService");
Assert.assertEquals("some b component value", service.getBProperty());
Assert.assertEquals("some b2 component value", service.getB2Property());
cleanupDomain();
}
/**
* Lines 96-97:
* <p>
* There can be zero or more component elements within a composite.
*/
@Test
public void components2() throws Exception {
initDomain("zerocomponents.composite");
cleanupDomain();
}
/**
* Lines 142-143:
* <p>
* name (required) ?the name of the component. The name must be unique
* across all the components in the composite.
*/
@Test(expected = ServiceRuntimeException.class)
//@Ignore("TUSCANY-2455")
public void components3() throws Exception {
initDomain("nonuniquename.composite");
cleanupDomain();
}
/**
* Lines 154-158:
* <p>
* A component element has zero or one implementation element as its child,
* which points to the implementation used by the component. A component
* with no implementation element is not runnable, but components of this
* kind may be useful during a "top-down" development process as a means of
* defining the characteristics required of the implementation before the
* implementation is written.
*/
@Test
public void components4() throws Exception {
initDomain("zeroimplelements.composite");
cleanupDomain();
}
/**
* Lines 159-160:
* <p>
* The component element can have zero or more service elements as children
* which are used to configure the services of the component.
*/
@Test
public void components5() throws Exception {
initDomain("serviceelement.composite");
cleanupDomain();
}
/**
* Lines 174-179:
* <p>
* A service has zero or one interface, which describes the operations
* provided by the service. The interface is described by an interface
* element which is a child element of the service element. If no interface
* is specified, then the interface specified for the service by the
* implementation is in effect. If an interface is specified it must provide
* a compatible subset of the interface provided by the implementation, i.e.
* provide a subset of the operations defined by the implementation for the
* service.
*/
@Test
public void components6() throws Exception {
initDomain("servicewithinterface.composite");
CService service = ServiceFinder.getService(CService.class, "CComponent");
Assert.assertEquals("Some State", service.getState());
cleanupDomain();
}
/**
* Lines 180-182:
* <p>
* A service element has one or more binding elements as children. If no
* bindings are specified, then the bindings specified for the service by
* the implementation are in effect. If bindings are specified, then those
* bindings override the bindings specified by the implementation.
*/
@Test
public void components7() throws Exception {
initDomain("servicewithbinding.composite");
CService service = ServiceFinder.getService(CService.class, "CComponent");
Assert.assertEquals("Some State", service.getState());
cleanupDomain();
}
/**
* Lines 599-601:
* <p>
* ASM50001
* <p>
* The @name attribute of a <service/> child element of a <componentType/> MUST
* be unique amongst the service elements of that <componentType/>
*
*/
@Test(expected=ServiceRuntimeException.class)
@Ignore("TUSCANY-2675")
public void ASM50001() throws Exception {
initDomain("nonuniqueservicenameincomponenttype.composite");
AService service = ServiceFinder.getService(AService.class, "ABComponent/AService");
Assert.assertEquals("OK", service.getState());
cleanupDomain();
}
/**
* Lines 695-697:
* <p>
* ASM50002
* <p>
* The @name attribute of a service element of a <component/> MUST be unique amongst
* the service elements of that <component/>
*
*/
@Test(expected=ServiceRuntimeException.class)
public void ASM50002() throws Exception {
initDomain("nonuniqueservicenameincomposite.composite");
DService service = ServiceFinder.getService(DService.class, "CDComponent/CServiceImpl");
Assert.assertEquals("hello", service.sayHello());
cleanupDomain();
}
/**
* Lines 697-699:
* <p>
* ASM50003
* <p>
* OSOA
* The @name attribute of a service element of a <component/> MUST match the
* @name attribute of a service element of the componentType of the <implementation/> child element of the component.
* <p>
* OASIS
* the name of the service has to match a name of a service defined by the implementation
*
*/
@Test(expected=ServiceRuntimeException.class)
public void ASM50003() throws Exception {
initDomain("notmatchofservicename.composite");
DService service = ServiceFinder.getService(DService.class, "DComponent1/DService1");
Assert.assertEquals("hello", service.sayHello());
cleanupDomain();
}
/**
* Lines 709-715:
* <p>
* ASM50004
* <p>
* If a <service/> element has an interface subelement specified, the interface MUST
* provide a compatible subset of the interface declared on the componentType of the
* implementation.
*/
@Test(expected=ServiceRuntimeException.class)
public void ASM50004() throws Exception {
//for this case, if you remove the method3() in the EEService
//the EEService will be a compatible subset of EService.
initDomain("notcompatibleinterface.composite");
EEService service = ServiceFinder.getService(EEService.class, "EEComponent/EEService");
Assert.assertEquals("method1", service.method1());
cleanupDomain();
}
}
|
