> getHeaders();
34 |
35 | int getStatus();
36 |
37 | String getUrl();
38 |
39 | }
40 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/Status.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse;
12 |
13 |
14 |
15 | /**
16 | * The Status enumeration contains values that can be used within a request/response
17 | * to represent it's status code. All values available in the official RFC 2616
18 | * (http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html) are implemented.
19 | *
20 | * @see Request
21 | * @see Response
22 | */
23 | public enum Status {
24 |
25 | // Informational 1xx
26 | CONTINUE( 100, "Continue" ),
27 | SWITCHING_PROTOCOLS( 101, "Switching Protocols" ),
28 | // Successful 2xx
29 | OK( 200, "OK" ),
30 | CREATED( 201, "Created" ),
31 | ACCEPTED( 202, "Accepted" ),
32 | NON_AUTHORITATIVE_INFORMATION( 203, "Non-Authoritative Information" ),
33 | NO_CONTENT( 204, "No Content" ),
34 | RESET_CONTENT( 205, "Reset Content" ),
35 | PARTIAL_CONTENT( 206, "Partial Content" ),
36 | // Redirection 3xx
37 | MULTIPLE_CHOICES( 300, "Multiple Choices" ),
38 | MOVED_PERMANENTLY( 301, "Moved Permanently" ),
39 | FOUND( 302, "Found" ),
40 | SEE_OTHER( 303, "See Other" ),
41 | NOT_MODIFIED( 304, "Not Modified" ),
42 | USE_PROXY( 305, "Use Proxy" ),
43 | TEMPORARY_REDIRECT( 307, "Temporary Redirect" ),
44 | // Client Error 4xx
45 | BAD_REQUEST( 400, "Bad Request" ),
46 | UNAUTHORIZED( 401, "Unauthorized" ),
47 | PAYMENT_REQUIRED( 402, "Payment Required" ),
48 | FORBIDDEN( 403, "Forbidden" ),
49 | NOT_FOUND( 404, "Not Found" ),
50 | METHOD_NOT_ALLOWED( 405, "Method Not Allowed" ),
51 | NOT_ACCEPTABLE( 406, "Not Acceptable" ),
52 | PROXY_AUTHENTICATION_REQUIRED( 407, "Proxy Authentication Required" ),
53 | REQUEST_TIMEOUT( 408, "Request Timeout" ),
54 | CONFLICT( 409, "Conflict" ),
55 | GONE( 410, "Gone" ),
56 | LENGTH_REQUIRED( 411, "Length Required" ),
57 | PRECONDITION_FAILED( 412, "Precondition Failed" ),
58 | REQUEST_ENTITY_TOO_LARGE( 413, "Request Entity Too Large" ),
59 | REQUEST_URI_TOO_LONG( 414, "Request-URI Too Long" ),
60 | UNSUPPORTED_MEDIA_TYPE( 415, "Unsupported Media Type" ),
61 | REQUEST_RANGE_NOT_SATISFIABLE( 416, "Requested Range Not Satisfiable" ),
62 | EXPECTATION_FAILED( 417, "Expectation Failed" ),
63 | // Server Error 5xx
64 | INTERNAL_SERVER_ERROR( 500, "Internal Server Error" ),
65 | NOT_IMPLEMENTED( 501, "Not Implemented" ),
66 | BAD_GATEWAY( 502, "Bad Gateway" ),
67 | SERVICE_UNAVAILABLE( 503, "Service Unavailable" ),
68 | GATEWAY_TIMEOUT( 504, "Gateway Timeout" ),
69 | HTTP_VERSION_NOT_SUPPORTED( 505, "HTTP Version Not Supported" );
70 |
71 | public enum Family { INFORMATIONAL, SUCCESSFUL, REDIRECTION, CLIENT_ERROR, SERVER_ERROR, UNKNOWN }
72 |
73 | private final int code;
74 | private final String reason;
75 | private Family family;
76 |
77 | Status( int statusCode, String reasonPhrase ) {
78 | this.code = statusCode;
79 | this.reason = reasonPhrase;
80 | assignFamily();
81 | }
82 |
83 | private void assignFamily() {
84 | switch( code / 100 ) {
85 | case 1:
86 | this.family = Family.INFORMATIONAL;
87 | break;
88 | case 2:
89 | this.family = Family.SUCCESSFUL;
90 | break;
91 | case 3:
92 | this.family = Family.REDIRECTION;
93 | break;
94 | case 4:
95 | this.family = Family.CLIENT_ERROR;
96 | break;
97 | case 5:
98 | this.family = Family.SERVER_ERROR;
99 | break;
100 | default:
101 | this.family = Family.UNKNOWN;
102 | break;
103 | }
104 | }
105 |
106 | public int getStatusCode() {
107 | return code;
108 | }
109 |
110 | public Family getFamily() {
111 | return family;
112 | }
113 |
114 | public static Status forStatusCode( int code ) {
115 | Status[] values = Status.values();
116 | for( Status status : values ) {
117 | if( status.getStatusCode() == code ) {
118 | return status;
119 | }
120 | }
121 | return null;
122 | }
123 |
124 | @Override
125 | public String toString() {
126 | return reason;
127 | }
128 | }
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/annotation/Authentication.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.annotation;
12 |
13 | import java.lang.annotation.ElementType;
14 | import java.lang.annotation.Retention;
15 | import java.lang.annotation.RetentionPolicy;
16 | import java.lang.annotation.Target;
17 |
18 | import com.eclipsesource.restfuse.AuthenticationType;
19 |
20 |
21 | /**
22 | * The Authentication can be used within a {@link HttpTest} annotation
23 | * to send authentication information within an outgoing http request. Currently only BASIC and
24 | * DIGEST authentication are supported.
25 | *
26 | * @see AuthenticationType
27 | */
28 | @Retention( RetentionPolicy.RUNTIME )
29 | @Target( { ElementType.ANNOTATION_TYPE } )
30 | public @interface Authentication {
31 |
32 | /**
33 | * The type attribute specifies the type of the authentication method. Currently
34 | * only BASIC and DIGEST authentication are supported. This may change in future.
35 | *
36 | * @see AuthenticationType
37 | */
38 | AuthenticationType type();
39 |
40 | String user();
41 |
42 | String password();
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/annotation/Callback.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.annotation;
12 |
13 | import java.lang.annotation.ElementType;
14 | import java.lang.annotation.Retention;
15 | import java.lang.annotation.RetentionPolicy;
16 | import java.lang.annotation.Target;
17 |
18 | import com.eclipsesource.restfuse.CallbackResource;
19 | import com.eclipsesource.restfuse.DefaultCallbackResource;
20 | import com.eclipsesource.restfuse.Destination;
21 |
22 |
23 | /**
24 | * The Callback can be used for asynchronous HTTP tests that need a callback.
25 | * This means when the tested service needs to send something back within a separate request. At
26 | * this time the client needs to act as a service to accept the incoming request. See
27 | * this wiki for more information
28 | * about webhooks.
29 | *
30 | * Please note, that the Callback annotation only works in combination with the
31 | * {@link HttpTest} annotation. This means it can't be used standalone and it
32 | * has the same prerequisites as the {@link HttpTest}.
33 | *
34 | * Once a request has finished on an http test method and the method has a Callback
35 | * annotation attached, a sever will be started before the test code will be executed. On this
36 | * server a servlet will be registered on the port specified in the port attribute
37 | * using the path specified in the path attribute. After the test code finished the
38 | * server waits until the timeout has reached or the callback was called. If the
39 | * callback was not done than the test method fails. In any case the server shuts itself down after
40 | * the test method execution.
41 | *
42 | * Of course you want to test something when the callback arrives. Therefore you need to register
43 | * a resource using the resource attribute. The value of this attributes has to be a
44 | * subclass of {@link CallbackResource}. For convenience you can also subclass the
45 | * {@link DefaultCallbackResource} which implements all methods and returns a default
46 | * response instead of sub classing the {@link CallbackResource} directly.
47 | *
48 | * A simple callback looks like this:
49 | *
50 | * @RunWith( HttpJUnitRunner.class )
51 | * public class Example {
52 | *
53 | * @Rule
54 | * public Destination destination = new Destination( "http://localhost" );
55 | *
56 | * @Context
57 | * private Response response;
58 | *
59 | * private class TestCallbackResource extends DefaultCallbackResource {
60 | *
61 | * @Override
62 | * public Response post( Request request ) {
63 | * assertNotNull( request.getHeaders().get( "some header" ).get( 0 ) );
64 | * return super.post( request );
65 | * }
66 | * }
67 | *
68 | * @HttpTest( method = Method.GET, path = "/test" )
69 | * @Callback( port = 9090, path = "/callback", resource = TestCallbackResource.class, timeout = 10000 )
70 | * public void testMethod() {
71 | * com.eclipsesource.restfuse.Assert.assertAccepted( response );
72 | * }
73 | * }
74 | *
75 | *
76 | *
77 | * @see CallbackResource
78 | * @see DefaultCallbackResource
79 | * @see HttpTest
80 | * @see Destination
81 | */
82 | @Retention( RetentionPolicy.RUNTIME )
83 | @Target( { ElementType.METHOD } )
84 | public @interface Callback {
85 |
86 | /**
87 | * The port attribute specifies the port on which the callback will be reachable
88 | * during the test method execution.
89 | */
90 | int port();
91 |
92 | /**
93 | * The path attribute specifies the path on which the callback will be reachable
94 | * during the test method execution.
95 | */
96 | String path();
97 |
98 | /**
99 | * The resource attribute specifies the class that will be instantiated and
100 | * handles the incoming requests from a callback. Instead of sub classing
101 | * {@link CallbackResource} directly you can also subclass
102 | * {@link DefaultCallbackResource} which implements all methods and returns a
103 | * default response.
104 | *
105 | * @see CallbackResource
106 | * @see DefaultCallbackResource
107 | */
108 | Class resource();
109 |
110 | /**
111 | * The timeout attribute specifies the milliseconds of the callback timeout. This
112 | * means, that if the callback was not called within the given time frame, the test method will
113 | * fail.
114 | */
115 | int timeout();
116 | }
117 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/annotation/Context.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.annotation;
12 |
13 | import java.lang.annotation.ElementType;
14 | import java.lang.annotation.Retention;
15 | import java.lang.annotation.RetentionPolicy;
16 | import java.lang.annotation.Target;
17 |
18 | import com.eclipsesource.restfuse.Destination;
19 | import com.eclipsesource.restfuse.PollState;
20 | import com.eclipsesource.restfuse.Response;
21 |
22 |
23 | /**
24 | * The Context annotation can be used within a TestCase to get the
25 | * {@link Response} or a {@link PollState} of an
26 | * HTTP request injected after it succeeds.
27 | *
28 | * A simple example looks like this:
29 | *
30 | * @RunWith( HttpJUnitRunner.class )
31 | * public class Example {
32 | *
33 | * @Rule
34 | * public Destination destination = new Destination( "http://localhost" );
35 | *
36 | * @Context
37 | * private Response response;
38 | *
39 | * @HttpTest( method = Method.GET, path = "/test" )
40 | * public void testMethod() {
41 | * com.eclipsesource.restfuse.Assert.assertAccepted( response );
42 | * }
43 | * }
44 | *
45 | *
46 | *
47 | * @see HttpTest
48 | * @see Destination
49 | */
50 | @Retention( RetentionPolicy.RUNTIME )
51 | @Target( { ElementType.FIELD } )
52 | public @interface Context {
53 | // no content
54 | }
55 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/annotation/Header.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.annotation;
12 |
13 | import java.lang.annotation.ElementType;
14 | import java.lang.annotation.Retention;
15 | import java.lang.annotation.RetentionPolicy;
16 | import java.lang.annotation.Target;
17 |
18 | /**
19 | * The Header annotation represents a single header attribute of an http request.
20 | * This headers can be set in a {@link HttpTest} annotation attached to a test method.
21 | *
22 | *
23 | * @see HttpTest
24 | */
25 | @Retention( RetentionPolicy.RUNTIME )
26 | @Target( { ElementType.ANNOTATION_TYPE } )
27 | public @interface Header {
28 |
29 | /**
30 | * The name attribute represents the name of the header element which comes before
31 | * the ":" within a request header.
32 | */
33 | String name();
34 |
35 | /**
36 | * The value attribute represents the value of the header element which comes
37 | * after the ":" within a request header.
38 | */
39 | String value();
40 | }
41 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/annotation/HttpTest.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.annotation;
12 |
13 | import java.lang.annotation.ElementType;
14 | import java.lang.annotation.Retention;
15 | import java.lang.annotation.RetentionPolicy;
16 | import java.lang.annotation.Target;
17 |
18 | import com.eclipsesource.restfuse.AuthenticationType;
19 | import com.eclipsesource.restfuse.Destination;
20 | import com.eclipsesource.restfuse.HttpJUnitRunner;
21 | import com.eclipsesource.restfuse.MediaType;
22 | import com.eclipsesource.restfuse.Method;
23 | import com.eclipsesource.restfuse.Response;
24 | import com.eclipsesource.restfuse.internal.AuthenticationInfo;
25 |
26 |
27 | /**
28 | * The HttpTest annotation tells JUnit that the public void method
29 | * to which it is attached can be run as an http test case when it's coupled with a Test
30 | * annotation. Before the test method will be executed an request will be send to the service
31 | * configured via the Destination rule and the annotation's parameters.
32 | * Please keep in mind that an HttpTest only works when a
33 | * {@link Destination} Rule exists in the TestCase.
34 | * If the request fails, the test fails. When the request succeeds, the Response
35 | * will be injected into the TestCase Object. The injection looks for a field of the type
36 | * {@link Response} which is annotated with the {@link Context}
37 | * annotation. The response object can also be pulled using the getRespone() method
38 | * on the {@link Destination} rule.
39 | * You don't have to combine the {@link org.junit.Test} and HttpTest
40 | * annotation when you are using the {@link HttpJUnitRunner}. This runner detects all
41 | * HttpTest annotated methods and executes them as test methods.
42 | *
43 | * To run the method, JUnit first constructs a fresh instance of the class. Then the request will
44 | * be executed and JUnit invokes the annotated method afterwards. Any exceptions thrown by the
45 | * test will be reported by JUnit as a failure. If no exceptions are thrown, the test is assumed
46 | * to have succeeded.
47 | *
48 | * A simple http test looks like this:
49 | *
50 | * @RunWith( HttpJUnitRunner.class )
51 | * public class Example {
52 | *
53 | * @Rule
54 | * public Destination destination = new Destination( "http://localhost" );
55 | *
56 | * @Context
57 | * private Response response;
58 | *
59 | * @HttpTest( method = Method.GET, path = "/test" )
60 | * public void testMethod() {
61 | * com.eclipsesource.restfuse.Assert.assertAccepted( response );
62 | * }
63 | * }
64 | *
65 | *
66 | *
67 | */
68 | @Retention( RetentionPolicy.RUNTIME )
69 | @Target( { ElementType.METHOD } )
70 | public @interface HttpTest {
71 |
72 | /**
73 | * The method attribute tells the request which Http Method should be used.
74 | *
75 | * @see Method
76 | */
77 | Method method();
78 |
79 | /**
80 | * The path attribute will be attached to the base url of the {@link Destination}
81 | * rule. This enables the creation of many http test method within one TestCase using different
82 | * url paths for the same host.
83 | */
84 | String path();
85 |
86 | /**
87 | * The type attribute tells the request which "Content-Type" header it should send. The default
88 | * value is the wildcard type.
89 | *
90 | * @see MediaType
91 | */
92 | MediaType type() default MediaType.WILDCARD;
93 |
94 | /**
95 | * When the request can have an entity like POST or PUT requests the content can be set by the
96 | * file attribute. The file has to be on the classpath of the TestCase. An
97 | * alternative can be to use the content attribute. If both are defined the
98 | * file attribute wins.
99 | */
100 | String file() default EMPTY;
101 |
102 | /**
103 | * When the request can have an entity like POST or PUT requests the content can be set by the
104 | * content attribute. An alternative can be to use the file attribute.
105 | * If both are defined the file attribute wins.
106 | */
107 | String content() default EMPTY;
108 |
109 | /**
110 | * With the headers the request headers can be set.
111 | *
112 | * @see Header
113 | */
114 | Header[] headers() default {};
115 |
116 | /**
117 | * PROVISIONAL API, MAY CHANGE OR VANISH IN FUTURE
118 | * The {@link AuthenticationInfo} will be used to transmit authentication data.
119 | * Currently only BASIC and DIGEST authentication is supported.
120 | *
121 | * @see AuthenticationInfo
122 | * @see AuthenticationType
123 | */
124 | Authentication[] authentications() default {};
125 |
126 | /**
127 | * Order of test in case tests need to be executed in certain order. 1 = first, 2 = second, ...
128 | * By default order is set to 0
129 | *
130 | *
131 | * @since 1.2
132 | */
133 | int order() default 0;
134 |
135 | static final String EMPTY = "";
136 |
137 | }
138 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/annotation/Poll.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.annotation;
12 |
13 | import java.lang.annotation.ElementType;
14 | import java.lang.annotation.Retention;
15 | import java.lang.annotation.RetentionPolicy;
16 | import java.lang.annotation.Target;
17 |
18 | import com.eclipsesource.restfuse.Destination;
19 | import com.eclipsesource.restfuse.PollState;
20 | import com.eclipsesource.restfuse.Response;
21 |
22 |
23 | /**
24 | * The Poll annotation can be used for asynchronous HTTP tests that need to poll
25 | * the service more than one times.
26 | *
27 | *
Please note, that the Poll annotation only works in combination with the
28 | * {@link HttpTest} annotation. This means it can't be used standalone and it
29 | * has the same prerequisites as the {@link HttpTest}.
30 | *
31 | * By annotating a test method with Poll you tell the framework to send the request
32 | * defined in the HttpTest more than one times. The amount of requests can be
33 | * configured via the times attribute.
34 | *
35 | * Once a single request has finished on an HTTP test method and the method has a
36 | * Poll annotation attached, a {@link PollState} object will be injected into the
37 | * Test object. The {@link PollState} field needs to be annotated with the
38 | * {@link Context} annotation and can be used to get a response for a specific
39 | * request during a poll series. The last response will be also injected when a
40 | * {@link Context} annotated {@link Response} field is available in the
41 | * test object. After the injection, the test method will be executed.
42 | *
43 | * A simple poll looks like this:
44 | *
45 | * @RunWith( HttpJUnitRunner.class )
46 | * public class Example {
47 | *
48 | * @Rule
49 | * public Destination destination = new Destination( "http://localhost" );
50 | *
51 | * @Context
52 | * private PollState pollState;
53 | *
54 | * @Context
55 | * private Response response;
56 | *
57 | * @HttpTest( method = Method.GET, path = "/test" )
58 | * @Poll( times = 5, interval = 500 )
59 | * public void testMethod() {
60 | * Response currentResponse = pollState.getResponse( pollState.getTimes() );
61 | * com.eclipsesource.restfuse.Assert.assertAccepted( currentResponse );
62 | * assertEquals( currentResponse, response );
63 | * }
64 | * }
65 | *
66 | *
67 | *
68 | * @see PollState
69 | * @see HttpTest
70 | * @see Destination
71 | * @see Context
72 | */
73 | @Retention( RetentionPolicy.RUNTIME )
74 | @Target( { ElementType.METHOD } )
75 | public @interface Poll {
76 |
77 | /**
78 | * The times attribute specifies the amount of requests that needs to be send
79 | * before JUnit will continue with the next test method.
80 | */
81 | int times();
82 |
83 | /**
84 | * The interval attribute specifies the idle time in milliseconds between two
85 | * requests in a poll series.
86 | */
87 | int interval();
88 | }
89 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/AuthenticationInfo.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal;
12 |
13 | import com.eclipsesource.restfuse.AuthenticationType;
14 |
15 |
16 | public class AuthenticationInfo {
17 |
18 | private final AuthenticationType type;
19 | private final String user;
20 | private final String password;
21 |
22 | public AuthenticationInfo( AuthenticationType type, String user, String password ) {
23 | this.type = type;
24 | this.user = user;
25 | this.password = password;
26 | }
27 |
28 | public AuthenticationType getType() {
29 | return type;
30 | }
31 |
32 | public String getUser() {
33 | return user;
34 | }
35 |
36 | public String getPassword() {
37 | return password;
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/BasicStatement.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal;
12 |
13 | import org.junit.runners.model.Statement;
14 |
15 | import com.eclipsesource.restfuse.Response;
16 |
17 |
18 | public class BasicStatement extends Statement {
19 |
20 | private final Statement statement;
21 | private final HttpTestStatement base;
22 |
23 | public BasicStatement( Statement statement, HttpTestStatement base ) {
24 | this.base = base;
25 | this.statement = statement;
26 | }
27 |
28 | @Override
29 | public void evaluate() throws Throwable {
30 | Response response = base.sendRequest();
31 | base.tryInjectResponse( response );
32 | statement.evaluate();
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/HttpTestStatement.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal;
12 |
13 | import java.lang.reflect.Field;
14 | import java.util.Properties;
15 |
16 | import org.junit.runner.Description;
17 | import org.junit.runners.model.Statement;
18 |
19 | import com.eclipsesource.restfuse.Method;
20 | import com.eclipsesource.restfuse.RequestContext;
21 | import com.eclipsesource.restfuse.Response;
22 | import com.eclipsesource.restfuse.annotation.Callback;
23 | import com.eclipsesource.restfuse.annotation.Context;
24 | import com.eclipsesource.restfuse.annotation.HttpTest;
25 | import com.eclipsesource.restfuse.annotation.Poll;
26 | import com.eclipsesource.restfuse.internal.callback.CallbackStatement;
27 | import com.eclipsesource.restfuse.internal.poll.PollStatement;
28 |
29 |
30 | public class HttpTestStatement extends Statement {
31 |
32 | static final String HTTP_PROXY_HOST = "http.proxyHost";
33 | static final String HTTP_PROXY_PORT = "http.proxyPort";
34 |
35 | private final Statement base;
36 | private final Description description;
37 | private final Object target;
38 | private final String baseUrl;
39 | private final String proxyHost;
40 | private final int proxyPort;
41 | private final RequestContext context;
42 |
43 | public HttpTestStatement( Statement base,
44 | Description description,
45 | Object target,
46 | String baseUrl,
47 | String proxyHost,
48 | int proxyPort,
49 | RequestContext context)
50 | {
51 | this.base = base;
52 | this.description = description;
53 | this.target = target;
54 | this.baseUrl = baseUrl;
55 | this.proxyHost = proxyHost;
56 | this.proxyPort = proxyPort;
57 | this.context = context;
58 | }
59 |
60 | @Override
61 | public void evaluate() throws Throwable {
62 | setProxyProperties();
63 | try {
64 | doEvaluate();
65 | } finally {
66 | unsetProxyProperties();
67 | }
68 | }
69 |
70 | private void setProxyProperties() {
71 | if( proxyHost != null ) {
72 | System.setProperty( HTTP_PROXY_HOST, proxyHost );
73 | System.setProperty( HTTP_PROXY_PORT, String.valueOf( proxyPort ) );
74 | }
75 | }
76 |
77 | private void doEvaluate() throws Throwable {
78 | Statement delegate = new BasicStatement( base, this );
79 | if( needsCallback() ) {
80 | delegate = new CallbackStatement( base, this, description, target );
81 | } else if( needsPoll() ) {
82 | delegate = new PollStatement( base, this, description, target );
83 | }
84 | delegate.evaluate();
85 | }
86 |
87 | private void unsetProxyProperties() {
88 | Properties properties = System.getProperties();
89 | properties.remove( HTTP_PROXY_HOST );
90 | properties.remove( HTTP_PROXY_PORT );
91 | }
92 |
93 | private boolean needsCallback() {
94 | Callback callbackAnnotation = description.getAnnotation( Callback.class );
95 | return callbackAnnotation != null;
96 | }
97 |
98 | private boolean needsPoll() {
99 | Poll pollAnnotation = description.getAnnotation( Poll.class );
100 | return pollAnnotation != null;
101 | }
102 |
103 | public Response sendRequest() {
104 | InternalRequest request = buildRequest();
105 | return callService( request );
106 | }
107 |
108 | private InternalRequest buildRequest() {
109 | RequestConfiguration requestConfiguration = new RequestConfiguration( baseUrl, description, target );
110 | return requestConfiguration.createRequest( context );
111 | }
112 |
113 | private Response callService( InternalRequest request ) {
114 | Method requestMethod = description.getAnnotation( HttpTest.class ).method();
115 | Response result = null;
116 | if( requestMethod.equals( Method.GET ) ) {
117 | result = request.get();
118 | } else if( requestMethod.equals( Method.POST ) ) {
119 | result = request.post();
120 | } else if( requestMethod.equals( Method.DELETE ) ) {
121 | result = request.delete();
122 | } else if( requestMethod.equals( Method.PUT ) ) {
123 | result = request.put();
124 | } else if( requestMethod.equals( Method.HEAD ) ) {
125 | result = request.head();
126 | } else if( requestMethod.equals( Method.OPTIONS ) ) {
127 | result = request.options();
128 | }
129 | return result;
130 | }
131 |
132 | public void tryInjectResponse( Response response ) {
133 | Field[] fields = target.getClass().getDeclaredFields();
134 | for( Field field : fields ) {
135 | Context contextAnnotation = field.getAnnotation( Context.class );
136 | if( contextAnnotation != null && field.getType() == Response.class ) {
137 | injectResponse( field, response );
138 | }
139 | }
140 | }
141 |
142 | private void injectResponse( Field field, Response response ) {
143 | field.setAccessible( true );
144 | try {
145 | field.set( target, response );
146 | } catch( Exception exception ) {
147 | throw new IllegalStateException( "Could not inject response.", exception );
148 | }
149 | }
150 |
151 | }
152 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/InternalRequest.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal;
12 |
13 | import java.io.InputStream;
14 | import java.util.ArrayList;
15 | import java.util.HashMap;
16 | import java.util.List;
17 | import java.util.Map;
18 | import java.util.Set;
19 |
20 | import com.eclipsesource.restfuse.AuthenticationType;
21 | import com.eclipsesource.restfuse.Response;
22 | import com.github.kevinsawicki.http.HttpRequest;
23 |
24 |
25 | public class InternalRequest {
26 |
27 | private final Map> headers;
28 | private final List authentications;
29 | private final String url;
30 | private InputStream content;
31 | private String mediaType;
32 |
33 | public InternalRequest( String url ) {
34 | this.url = url;
35 | headers = new HashMap>();
36 | authentications = new ArrayList();
37 | }
38 |
39 | public void setContentType( String mediaType ) {
40 | this.mediaType = mediaType;
41 | }
42 |
43 | public void setContent( InputStream content ) {
44 | this.content = content;
45 | }
46 |
47 | public void addHeader( String name, String value ) {
48 | List param = headers.get( name );
49 | if( param == null ) {
50 | List params = new ArrayList();
51 | params.add( value );
52 | headers.put( name, params );
53 | } else {
54 | param.add( value );
55 | }
56 | }
57 |
58 | public void addAuthenticationInfo( AuthenticationInfo authentication ) {
59 | authentications.add( authentication );
60 | }
61 |
62 | public Response get() {
63 | HttpRequest request = HttpRequest.get( url );
64 | addContentType( request );
65 | addHeaders( request );
66 | addAuthentication( request );
67 | sendRequest( request );
68 | return new ResponseImpl( request );
69 | }
70 |
71 | public Response post() {
72 | HttpRequest request = HttpRequest.post( url );
73 | addContentType( request );
74 | addHeaders( request );
75 | addAuthentication( request );
76 | request.send( content );
77 | sendRequest( request );
78 | return new ResponseImpl( request );
79 | }
80 |
81 | public Response delete() {
82 | HttpRequest request = HttpRequest.delete( url );
83 | addContentType( request );
84 | addHeaders( request );
85 | addAuthentication( request );
86 | sendRequest( request );
87 | return new ResponseImpl( request );
88 | }
89 |
90 | public Response put() {
91 | HttpRequest request = HttpRequest.put( url );
92 | addContentType( request );
93 | addHeaders( request );
94 | addAuthentication( request );
95 | request.send( content );
96 | sendRequest( request );
97 | return new ResponseImpl( request );
98 | }
99 |
100 | public Response head() {
101 | HttpRequest request = HttpRequest.head( url );
102 | addContentType( request );
103 | addHeaders( request );
104 | addAuthentication( request );
105 | sendRequest( request );
106 | return new ResponseImpl( request );
107 | }
108 |
109 | public Response options() {
110 | HttpRequest request = HttpRequest.options( url );
111 | addContentType( request );
112 | addHeaders( request );
113 | addAuthentication( request );
114 | sendRequest( request );
115 | return new ResponseImpl( request );
116 | }
117 |
118 |
119 | private void addContentType( HttpRequest request ) {
120 | String type = mediaType != null ? mediaType : "*/*";
121 | request.contentType( type );
122 | }
123 |
124 | private void addHeaders( HttpRequest request ) {
125 | Set keySet = headers.keySet();
126 | for( String key : keySet ) {
127 | List values = headers.get( key );
128 | StringBuilder builder = new StringBuilder();
129 | for( String value : values ) {
130 | builder.append( value + "," );
131 | }
132 | request.header( key, builder.substring( 0, builder.length() - 1 ) );
133 | }
134 | request.trustAllCerts();
135 | request.trustAllHosts();
136 | }
137 |
138 | private void addAuthentication( HttpRequest request ) {
139 | for( AuthenticationInfo authentication : authentications ) {
140 | if( authentication.getType().equals( AuthenticationType.BASIC ) ) {
141 | request.basic( authentication.getUser(), authentication.getPassword() );
142 | } else if( authentication.getType().equals( AuthenticationType.DIGEST ) ) {
143 | // TODO: implement digest auth
144 | }
145 | }
146 | }
147 |
148 | private void sendRequest( HttpRequest request ) {
149 | request.code();
150 | }
151 |
152 | String getUrl(){
153 | return url;
154 | }
155 | }
156 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/RequestConfiguration.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others. All rights reserved. This program and the
3 | * accompanying materials are made available under the terms of the Eclipse Public License v1.0
4 | * which accompanies this distribution, and is available at
5 | * http://www.eclipse.org/legal/epl-v10.html
6 | *
7 | * Contributors: Holger Staudacher - initial API and implementation
8 | *
9 | ******************************************************************************/
10 | package com.eclipsesource.restfuse.internal;
11 |
12 | import java.io.ByteArrayInputStream;
13 | import java.io.InputStream;
14 | import java.io.UnsupportedEncodingException;
15 | import java.net.URL;
16 | import java.util.Map;
17 | import java.util.regex.Matcher;
18 | import java.util.regex.Pattern;
19 |
20 | import org.junit.runner.Description;
21 |
22 | import com.eclipsesource.restfuse.AuthenticationType;
23 | import com.eclipsesource.restfuse.MediaType;
24 | import com.eclipsesource.restfuse.RequestContext;
25 | import com.eclipsesource.restfuse.annotation.Authentication;
26 | import com.eclipsesource.restfuse.annotation.Header;
27 | import com.eclipsesource.restfuse.annotation.HttpTest;
28 |
29 | public class RequestConfiguration {
30 |
31 | private static final String PATH_SEPARATOR = "/";
32 | private final String baseUrl;
33 | private final Description description;
34 | private final Object target;
35 |
36 | public RequestConfiguration( String baseUrl, Description description, Object target ) {
37 | this.baseUrl = baseUrl;
38 | this.description = description;
39 | this.target = target;
40 | }
41 |
42 | public InternalRequest createRequest( RequestContext context ) {
43 | HttpTest call = description.getAnnotation( HttpTest.class );
44 | String rawPath = combineUrlAndPath( baseUrl, call.path() );
45 | InternalRequest request = new InternalRequest( substituePathSegments( rawPath, context ) );
46 | addAuthentication( call, request );
47 | addContentType( call, request );
48 | addHeader( call, request, context );
49 | addBody( call, request );
50 | return request;
51 | }
52 |
53 | private String substituePathSegments( String path, RequestContext context ) {
54 | String substitutedPath = path;
55 | Pattern pattern = Pattern.compile( ".*?\\{(.*?)\\}.*?" );
56 | Matcher matcher = pattern.matcher( path );
57 | while( matcher.find() ) {
58 | String segment = matcher.group( 1 );
59 | checkSubstitutionExists( context, segment );
60 | substitutedPath = substitutedPath.replace( "{" + segment + "}",
61 | context.getPathSegments().get( segment ) );
62 | }
63 | return substitutedPath;
64 | }
65 |
66 | private void checkSubstitutionExists( RequestContext context, String segment ) {
67 | if( !context.getPathSegments().containsKey( segment ) ) {
68 | throw new IllegalStateException( "Misconfigured Destination. Could not replace {" + segment + "}." );
69 | }
70 | }
71 |
72 | private void addAuthentication( HttpTest call, InternalRequest request ) {
73 | Authentication[] authentications = call.authentications();
74 | if( authentications != null ) {
75 | for( Authentication authentication : authentications ) {
76 | AuthenticationType type = authentication.type();
77 | String user = authentication.user();
78 | String password = authentication.password();
79 | request.addAuthenticationInfo( new AuthenticationInfo( type, user, password ) );
80 | }
81 | }
82 | }
83 |
84 | private void addContentType( HttpTest call, InternalRequest request ) {
85 | MediaType contentType = call.type();
86 | if( contentType != null ) {
87 | request.setContentType( contentType.getMimeType() );
88 | }
89 | }
90 |
91 | private void addHeader( HttpTest call, InternalRequest request, RequestContext context ) {
92 | addHeadersFromContext( request, context );
93 | addHeadersFromAnnotation( call, request );
94 | }
95 |
96 | private void addHeadersFromContext( InternalRequest request, RequestContext context ) {
97 | if( context != null && !context.getHeaders().isEmpty() ) {
98 | Map headers = context.getHeaders();
99 | for( String name : headers.keySet() )
100 | request.addHeader( name, headers.get( name ) );
101 | }
102 | }
103 |
104 | private void addHeadersFromAnnotation( HttpTest call, InternalRequest request ) {
105 | Header[] header = call.headers();
106 | if( header != null ) {
107 | for( Header parameter : header ) {
108 | request.addHeader( parameter.name(), parameter.value() );
109 | }
110 | }
111 | }
112 |
113 | private void addBody( HttpTest test, InternalRequest request ) {
114 | if( !test.file().equals( "" ) ) {
115 | request.setContent( getFileStream( test.file() ) );
116 | } else if( !test.content().equals( "" ) ) {
117 | request.setContent( getContentStream( test.content() ) );
118 | }
119 | }
120 |
121 | private InputStream getFileStream( String file ) {
122 | URL resource = target.getClass().getResource( file );
123 | try {
124 | return resource.openStream();
125 | } catch( Exception ioe ) {
126 | throw new IllegalStateException( "Could not open file "
127 | + file
128 | + ". Maybe it's not on the classpath?" );
129 | }
130 | }
131 |
132 | private InputStream getContentStream( String content ) {
133 | try {
134 | return new ByteArrayInputStream( content.getBytes( "UTF-8" ) );
135 | } catch( UnsupportedEncodingException shouldNotHappen ) {
136 | throw new IllegalStateException( shouldNotHappen );
137 | }
138 | }
139 |
140 | private String combineUrlAndPath( String url, String pathValue ) {
141 | String result;
142 | if( url.endsWith( PATH_SEPARATOR ) && pathValue.startsWith( PATH_SEPARATOR ) ) {
143 | result = url + pathValue.substring( 1, pathValue.length() );
144 | } else if( ( !url.endsWith( PATH_SEPARATOR ) && pathValue.startsWith( PATH_SEPARATOR ) )
145 | || ( url.endsWith( PATH_SEPARATOR ) && !pathValue.startsWith( PATH_SEPARATOR ) ) )
146 | {
147 | result = url + pathValue;
148 | } else if( !url.endsWith( PATH_SEPARATOR ) && !pathValue.startsWith( PATH_SEPARATOR ) ) {
149 | result = url + PATH_SEPARATOR + pathValue;
150 | } else {
151 | throw new IllegalStateException( "Invalid url format with base url "
152 | + url
153 | + " and path "
154 | + pathValue );
155 | }
156 | return result;
157 | }
158 | }
159 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/RequestImpl.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal;
12 |
13 | import java.util.ArrayList;
14 | import java.util.HashMap;
15 | import java.util.List;
16 | import java.util.Map;
17 |
18 | import com.eclipsesource.restfuse.MediaType;
19 | import com.eclipsesource.restfuse.Request;
20 |
21 |
22 | public class RequestImpl implements Request {
23 |
24 |
25 | private Map> headers;
26 | private final MediaType contentType;
27 | private final String body;
28 |
29 | public RequestImpl( String body, MediaType contentType ) {
30 | this.body = body;
31 | this.contentType = contentType;
32 | headers = new HashMap>();
33 | }
34 |
35 | @Override
36 | public boolean hasBody() {
37 | return body != null;
38 | }
39 |
40 | @Override
41 | public String getBody() {
42 | return body;
43 | }
44 |
45 | @Override
46 | public MediaType getType() {
47 | return contentType;
48 | }
49 |
50 | @Override
51 | public Map> getHeaders() {
52 | return headers;
53 | }
54 |
55 | public void addHeader( String name, String value ) {
56 | List param = headers.get( name );
57 | if( param == null ) {
58 | List params = new ArrayList();
59 | params.add( value );
60 | headers.put( name, params );
61 | } else {
62 | param.add( value );
63 | }
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/ResponseImpl.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal;
12 |
13 | import java.util.List;
14 | import java.util.Map;
15 |
16 | import com.eclipsesource.restfuse.MediaType;
17 | import com.eclipsesource.restfuse.Response;
18 | import com.github.kevinsawicki.http.HttpRequest;
19 |
20 |
21 | public class ResponseImpl implements Response {
22 |
23 | private final String body;
24 | private final String contentType;
25 | private final Map> headers;
26 | private final int code;
27 | private final String url;
28 |
29 | public ResponseImpl( HttpRequest request ) {
30 | body = request.body();
31 | contentType = request.contentType();
32 | headers = request.headers();
33 | code = request.code();
34 | url = request.getConnection().getURL().toString();
35 | request.disconnect();
36 | }
37 |
38 | @Override
39 | public boolean hasBody() {
40 | return body != null;
41 | }
42 |
43 | @Override
44 | @SuppressWarnings( "unchecked" )
45 | public T getBody( Class type ) {
46 | if( type != String.class ) {
47 | throw new IllegalArgumentException( "Only String is supported. Not the this method is deprecated, see getBody()." );
48 | }
49 | return ( T )body;
50 | }
51 |
52 | @Override
53 | public String getBody() {
54 | return body;
55 | }
56 |
57 | @Override
58 | public MediaType getType() {
59 | return MediaType.fromString( contentType );
60 | }
61 |
62 | @Override
63 | public Map> getHeaders() {
64 | return headers;
65 | }
66 |
67 | @Override
68 | public int getStatus() {
69 | return code;
70 | }
71 |
72 | @Override
73 | public String getUrl() {
74 | return url;
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/callback/CallbackSerlvet.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal.callback;
12 |
13 | import java.io.BufferedReader;
14 | import java.io.IOException;
15 | import java.util.Enumeration;
16 | import java.util.List;
17 | import java.util.Map;
18 | import java.util.Set;
19 |
20 | import javax.servlet.ServletException;
21 | import javax.servlet.http.HttpServlet;
22 | import javax.servlet.http.HttpServletRequest;
23 | import javax.servlet.http.HttpServletResponse;
24 |
25 | import com.eclipsesource.restfuse.CallbackResource;
26 | import com.eclipsesource.restfuse.MediaType;
27 | import com.eclipsesource.restfuse.Response;
28 | import com.eclipsesource.restfuse.Request;
29 | import com.eclipsesource.restfuse.internal.RequestImpl;
30 |
31 |
32 | public class CallbackSerlvet extends HttpServlet {
33 |
34 | private boolean wasCalled;
35 | private final CallbackResource resource;
36 | private final CallbackStatement statement;
37 |
38 | public CallbackSerlvet( CallbackResource resource, CallbackStatement callbackStatement ) {
39 | this.resource = resource;
40 | this.statement = callbackStatement;
41 | }
42 |
43 | @Override
44 | protected void doGet( HttpServletRequest req, HttpServletResponse resp )
45 | throws ServletException, IOException
46 | {
47 | try {
48 | createResponse( resp, resource.get( createRequest( req ) ) );
49 | } catch( Throwable failure ) {
50 | statement.failWithinCallback( failure );
51 | }
52 | wasCalled = true;
53 | }
54 |
55 | @Override
56 | protected void doPost( HttpServletRequest req, HttpServletResponse resp )
57 | throws ServletException, IOException
58 | {
59 | try {
60 | createResponse( resp, resource.post( createRequest( req ) ) );
61 | } catch( Throwable failure ) {
62 | statement.failWithinCallback( failure );
63 | }
64 | wasCalled = true;
65 | }
66 |
67 | @Override
68 | protected void doPut( HttpServletRequest req, HttpServletResponse resp )
69 | throws ServletException, IOException
70 | {
71 | try {
72 | createResponse( resp, resource.put( createRequest( req ) ) );
73 | } catch( Throwable failure ) {
74 | statement.failWithinCallback( failure );
75 | }
76 | wasCalled = true;
77 | }
78 |
79 | @Override
80 | protected void doDelete( HttpServletRequest req, HttpServletResponse resp )
81 | throws ServletException, IOException
82 | {
83 | try {
84 | createResponse( resp, resource.delete( createRequest( req ) ) );
85 | } catch( Throwable failure ) {
86 | statement.failWithinCallback( failure );
87 | }
88 | wasCalled = true;
89 | }
90 |
91 | @Override
92 | protected void doHead( HttpServletRequest req, HttpServletResponse resp )
93 | throws ServletException, IOException
94 | {
95 | try {
96 | createResponse( resp, resource.head( createRequest( req ) ) );
97 | } catch( Throwable failure ) {
98 | statement.failWithinCallback( failure );
99 | }
100 | wasCalled = true;
101 | }
102 |
103 | @Override
104 | protected void doOptions( HttpServletRequest req, HttpServletResponse resp )
105 | throws ServletException, IOException
106 | {
107 | try {
108 | createResponse( resp, resource.options( createRequest( req ) ) );
109 | } catch( Throwable failure ) {
110 | statement.failWithinCallback( failure );
111 | }
112 | wasCalled = true;
113 | }
114 |
115 | private Request createRequest( HttpServletRequest req ) {
116 | MediaType mediaType = MediaType.fromString( req.getContentType() );
117 | String body = getBody( req );
118 | RequestImpl result = new RequestImpl( body, mediaType );
119 | addHeaderToRequest( req, result );
120 | return result;
121 | }
122 |
123 | private void addHeaderToRequest( HttpServletRequest req, RequestImpl request ) {
124 | @SuppressWarnings( "rawtypes" )
125 | Enumeration headerNames = req.getHeaderNames();
126 | if( headerNames != null ) {
127 | while( headerNames.hasMoreElements() ) {
128 | String name = ( String )headerNames.nextElement();
129 | String value = req.getHeader( name );
130 | request.addHeader( name, value );
131 | }
132 | }
133 | }
134 |
135 | private String getBody( HttpServletRequest req ) {
136 | String result = null;
137 | try {
138 | BufferedReader reader = req.getReader();
139 | String buffer = "";
140 | StringBuilder stringBuilder = new StringBuilder();
141 | while( ( buffer = reader.readLine() ) != null ) {
142 | stringBuilder.append( buffer );
143 | }
144 | reader.close();
145 | result = stringBuilder.toString();
146 | } catch( IOException shouldNotHappen ) {
147 | throw new IllegalStateException( shouldNotHappen );
148 | }
149 | return result;
150 | }
151 |
152 | private void createResponse( HttpServletResponse resp, Response response ) throws IOException {
153 | resp.setStatus( response.getStatus() );
154 | addHeadersToResponse( resp, response );
155 | addContentTypeToResponse( resp, response );
156 | addBodyToResponse( resp, response );
157 | }
158 |
159 | private void addHeadersToResponse( HttpServletResponse resp, Response response ) {
160 | Map> headers = response.getHeaders();
161 | if( headers != null ) {
162 | Set keySet = headers.keySet();
163 | for( String key : keySet ) {
164 | List values = headers.get( key );
165 | for( String value : values ) {
166 | resp.setHeader( key, value );
167 | }
168 | }
169 | }
170 | }
171 |
172 | private void addContentTypeToResponse( HttpServletResponse resp, Response response ) {
173 | MediaType type = response.getType();
174 | if( type != null ) {
175 | resp.setContentType( type.getMimeType() );
176 | }
177 | }
178 |
179 | private void addBodyToResponse( HttpServletResponse resp, Response response ) throws IOException {
180 | if( response.hasBody() ) {
181 | String body = response.getBody();
182 | resp.getWriter().write( body );
183 | resp.getWriter().close();
184 | }
185 | }
186 |
187 | public boolean wasCalled() {
188 | return wasCalled;
189 | }
190 | }
191 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/callback/CallbackServer.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal.callback;
12 |
13 | import java.lang.reflect.Constructor;
14 |
15 | import org.eclipse.jetty.server.Server;
16 | import org.eclipse.jetty.servlet.ServletContextHandler;
17 | import org.eclipse.jetty.servlet.ServletHolder;
18 |
19 | import com.eclipsesource.restfuse.CallbackResource;
20 | import com.eclipsesource.restfuse.annotation.Callback;
21 |
22 |
23 | public class CallbackServer {
24 |
25 | private CallbackResource resource;
26 | private int timeout;
27 | private int port;
28 | private String path;
29 | private Server server;
30 | private CallbackSerlvet servlet;
31 | private final CallbackStatement statement;
32 |
33 | public CallbackServer( Callback callbackAnnotation, Object target, CallbackStatement callbackStatement ) {
34 | createResource( callbackAnnotation.resource(), target );
35 | this.statement = callbackStatement;
36 | timeout = callbackAnnotation.timeout();
37 | port = callbackAnnotation.port();
38 | path = callbackAnnotation.path();
39 | }
40 |
41 | private void createResource( Class type, Object target ) {
42 | Thread currentThread = Thread.currentThread();
43 | ClassLoader originalClassLoader = currentThread.getContextClassLoader();
44 | try {
45 | currentThread.setContextClassLoader( target.getClass().getClassLoader() );
46 | doCreateResource( type, target );
47 | } finally {
48 | currentThread.setContextClassLoader( originalClassLoader );
49 | }
50 | }
51 |
52 | private void doCreateResource( Class type, Object target ) {
53 | try {
54 | Constructor constructor
55 | = type.getDeclaredConstructor( new Class[] { target.getClass() } );
56 | constructor.setAccessible( true );
57 | resource = constructor.newInstance( new Object[] { target } );
58 | } catch( Exception e ) {
59 | try {
60 | Constructor constructor = type.getDeclaredConstructor();
61 | constructor.setAccessible( true );
62 | resource = constructor.newInstance();
63 | } catch( Exception shouldNotHappen ) {
64 | throw new IllegalStateException( "Could not create resource instance of type "
65 | + type.getName() + ". Is there an default constructor?", shouldNotHappen );
66 | }
67 | }
68 | }
69 |
70 | public void start() {
71 | configureServer();
72 | doStartServer();
73 | }
74 |
75 | private void configureServer() {
76 | server = new Server( port );
77 | ServletContextHandler context = new ServletContextHandler( server, "/", ServletContextHandler.SESSIONS );
78 | servlet = new CallbackSerlvet( resource, statement );
79 | context.addServlet( new ServletHolder( servlet ), path );
80 | }
81 |
82 | private void doStartServer() {
83 | try {
84 | server.start();
85 | } catch( Exception shouldNotHappen ) {
86 | throw new IllegalStateException( "Could not start Http Server", shouldNotHappen );
87 | }
88 | }
89 |
90 | public void stop() {
91 | try {
92 | server.stop();
93 | } catch( Exception shouldNotHappen ) {
94 | throw new IllegalStateException( "Could not stop Http Server", shouldNotHappen );
95 | }
96 | }
97 |
98 | public boolean wasCalled() {
99 | return servlet.wasCalled();
100 | }
101 |
102 | public int getTimeout() {
103 | return timeout;
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/callback/CallbackStatement.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal.callback;
12 |
13 | import static org.junit.Assert.fail;
14 |
15 | import org.junit.runner.Description;
16 | import org.junit.runners.model.Statement;
17 |
18 | import com.eclipsesource.restfuse.Response;
19 | import com.eclipsesource.restfuse.annotation.Callback;
20 | import com.eclipsesource.restfuse.internal.HttpTestStatement;
21 |
22 |
23 | public class CallbackStatement extends Statement {
24 |
25 | private static final int WAIT_TIME = 100;
26 |
27 | private HttpTestStatement base;
28 | private Description description;
29 | private Object target;
30 | private CallbackServer callbackServer;
31 | private final Object lock = new Object();
32 | private volatile String errorMessage;
33 |
34 | private final Statement statement;
35 |
36 | public CallbackStatement( Statement statement,
37 | HttpTestStatement base,
38 | Description description,
39 | Object target )
40 | {
41 | this.statement = statement;
42 | this.base = base;
43 | this.description = description;
44 | this.target = target;
45 | }
46 |
47 | @Override
48 | public void evaluate() throws Throwable {
49 | try {
50 | startCallbackServerWhenAvailable();
51 | Response response = base.sendRequest();
52 | base.tryInjectResponse( response );
53 | statement.evaluate();
54 | } finally {
55 | waitForCallbackWhenAvailable();
56 | }
57 | }
58 |
59 | private void startCallbackServerWhenAvailable() {
60 | Callback callbackAnnotation = description.getAnnotation( Callback.class );
61 | if( callbackAnnotation != null ) {
62 | callbackServer = new CallbackServer( callbackAnnotation, target, this );
63 | callbackServer.start();
64 | }
65 | }
66 |
67 | private void waitForCallbackWhenAvailable() {
68 | if( callbackServer != null ) {
69 | try {
70 | int waitTime = 0;
71 | while( !callbackServer.wasCalled() && waitTime <= callbackServer.getTimeout() ) {
72 | sleep();
73 | waitTime += WAIT_TIME;
74 | }
75 | checkForFailuresDuringCallback();
76 | checkCallbackWasCalled();
77 | } finally {
78 | callbackServer.stop();
79 | }
80 | }
81 | }
82 |
83 | private void sleep() {
84 | try {
85 | Thread.sleep( WAIT_TIME );
86 | } catch( InterruptedException shouldNotHappen ) {
87 | throw new IllegalStateException( "Could not wait until callback was called",
88 | shouldNotHappen );
89 | }
90 | }
91 |
92 | private void checkForFailuresDuringCallback() {
93 | synchronized( lock ) {
94 | if( errorMessage != null ) {
95 | fail( errorMessage );
96 | }
97 | }
98 | }
99 |
100 | private void checkCallbackWasCalled() {
101 | if( !callbackServer.wasCalled() ) {
102 | fail( "Callback was not called" );
103 | }
104 | }
105 |
106 | public void failWithinCallback( Throwable cause ) {
107 | synchronized( lock ) {
108 | errorMessage = cause.getMessage();
109 | }
110 | }
111 | }
112 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/poll/PollStateImpl.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal.poll;
12 |
13 | import java.util.ArrayList;
14 | import java.util.List;
15 |
16 | import com.eclipsesource.restfuse.PollState;
17 | import com.eclipsesource.restfuse.Response;
18 |
19 |
20 | public class PollStateImpl implements PollState {
21 |
22 | private final ArrayList responses;
23 | private boolean wasAborted;
24 |
25 | public PollStateImpl() {
26 | responses = new ArrayList();
27 | }
28 |
29 | @Override
30 | public int getTimes() {
31 | return responses.size();
32 | }
33 |
34 | @Override
35 | public void abort() {
36 | wasAborted = true;
37 | }
38 |
39 | boolean wasAborted() {
40 | return wasAborted;
41 | }
42 |
43 | @Override
44 | public List getResponses() {
45 | return new ArrayList( responses );
46 | }
47 |
48 | @Override
49 | public Response getResponse( int attempt ) throws IllegalArgumentException {
50 | if( ( attempt - 1 ) > responses.size() ) {
51 | throw new IllegalArgumentException( "Response does not exist for attemt " + attempt );
52 | }
53 | return responses.get( attempt - 1 );
54 | }
55 |
56 | void addResponse( Response response ) {
57 | responses.add( response );
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/com.eclipsesource.restfuse/src/com/eclipsesource/restfuse/internal/poll/PollStatement.java:
--------------------------------------------------------------------------------
1 | /*******************************************************************************
2 | * Copyright (c) 2011 EclipseSource and others.
3 | * All rights reserved. This program and the accompanying materials
4 | * are made available under the terms of the Eclipse Public License v1.0
5 | * which accompanies this distribution, and is available at
6 | * http://www.eclipse.org/legal/epl-v10.html
7 | *
8 | * Contributors:
9 | * Holger Staudacher - initial API and implementation
10 | ******************************************************************************/
11 | package com.eclipsesource.restfuse.internal.poll;
12 |
13 | import java.lang.reflect.Field;
14 |
15 | import org.junit.runner.Description;
16 | import org.junit.runners.model.Statement;
17 |
18 | import com.eclipsesource.restfuse.PollState;
19 | import com.eclipsesource.restfuse.Response;
20 | import com.eclipsesource.restfuse.annotation.Context;
21 | import com.eclipsesource.restfuse.annotation.Poll;
22 | import com.eclipsesource.restfuse.internal.HttpTestStatement;
23 |
24 |
25 | public class PollStatement extends Statement {
26 |
27 | private final Statement statement;
28 | private final HttpTestStatement base;
29 | private int interval;
30 | private int times;
31 | private final Object target;
32 | private PollStateImpl pollState;
33 |
34 | public PollStatement( Statement statement,
35 | HttpTestStatement base,
36 | Description description,
37 | Object target )
38 | {
39 | this.statement = statement;
40 | this.base = base;
41 | this.target = target;
42 | Poll pollAnnotation = description.getAnnotation( Poll.class );
43 | interval = pollAnnotation.interval();
44 | times = pollAnnotation.times();
45 | pollState = new PollStateImpl();
46 | }
47 |
48 | @Override
49 | public void evaluate() throws Throwable {
50 | for( int i = 0; i < times && !pollState.wasAborted(); i++ ) {
51 | doSingleEvaluate();
52 | }
53 | }
54 |
55 | private void doSingleEvaluate() throws Throwable {
56 | Response response = base.sendRequest();
57 | base.tryInjectResponse( response );
58 | tryToInjectPollState( response );
59 | statement.evaluate();
60 | sleep();
61 | }
62 |
63 | private void tryToInjectPollState( Response response ) {
64 | pollState.addResponse( response );
65 | Field[] fields = target.getClass().getDeclaredFields();
66 | for( Field field : fields ) {
67 | Context contextAnnotation = field.getAnnotation( Context.class );
68 | if( contextAnnotation != null && field.getType() == PollState.class ) {
69 | injectPollState( field );
70 | }
71 | }
72 | }
73 |
74 | private void injectPollState( Field field ) {
75 | field.setAccessible( true );
76 | try {
77 | field.set( target, pollState );
78 | } catch( Exception exception ) {
79 | throw new IllegalStateException( "Could not inject pollstate.", exception );
80 | }
81 | }
82 |
83 | private void sleep() {
84 | try {
85 | Thread.sleep( interval );
86 | } catch( InterruptedException shouldNotHappen ) {
87 | throw new IllegalStateException( "Could not sleep until the next poll", shouldNotHappen );
88 | }
89 | }
90 | }
--------------------------------------------------------------------------------