View Javadoc

1   /**
2    * Copyright (c) 2002-2011 "Neo Technology,"
3    * Network Engine for Objects in Lund AB [http://neotechnology.com]
4    *
5    * This file is part of Neo4j.
6    *
7    * Neo4j is free software: you can redistribute it and/or modify
8    * it under the terms of the GNU General Public License as published by
9    * the Free Software Foundation, either version 3 of the License, or
10   * (at your option) any later version.
11   *
12   * This program is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   * GNU General Public License for more details.
16   *
17   * You should have received a copy of the GNU General Public License
18   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19   */
20  package org.neo4j.server.rest.repr;
21  
22  import static org.junit.Assert.assertTrue;
23  
24  import java.net.URI;
25  import java.util.ArrayList;
26  import java.util.HashMap;
27  import java.util.List;
28  import java.util.Map;
29  
30  import javax.ws.rs.core.MediaType;
31  
32  import org.neo4j.server.rest.repr.formats.ListWrappingWriter;
33  import org.neo4j.server.rest.repr.formats.MapWrappingWriter;
34  
35  public abstract class RepresentationTestBase
36  {
37      public static final URI BASE_URI = URI.create( "http://neo4j.org/" );
38      static final String NODE_URI_PATTERN = "http://.*/node/[0-9]+";
39      static final String RELATIONSHIP_URI_PATTERN = "http://.*/relationship/[0-9]+";
40  
41      static void assertUriMatches( String expectedRegex, ValueRepresentation uriRepr ) throws BadInputException
42      {
43          assertUriMatches( expectedRegex, serialize( uriRepr ) );
44      }
45  
46      static void assertUriMatches( String expectedRegex, URI actualUri )
47      {
48          assertUriMatches( expectedRegex, actualUri.toString() );
49      }
50  
51      public static Object serialize( Representation repr ) throws BadInputException
52      {
53          if ( repr instanceof ValueRepresentation )
54          {
55              return serialize( (ValueRepresentation) repr );
56          }
57          else if ( repr instanceof MappingRepresentation )
58          {
59              return serialize( (MappingRepresentation) repr );
60          }
61          else if ( repr instanceof ListRepresentation )
62          {
63              return serialize( (ListRepresentation) repr );
64          }
65          else
66          {
67              throw new IllegalArgumentException( repr.getClass().toString() );
68          }
69      }
70  
71      public static String serialize( ValueRepresentation repr ) throws BadInputException
72      {
73          return repr.serialize( new StringFormat(), BASE_URI, null );
74      }
75  
76      static void assertUriMatches( String expectedRegex, String actualUri )
77      {
78          assertTrue( "expected <" + expectedRegex + "> got <" + actualUri + ">",
79                  actualUri.matches( expectedRegex ) );
80      }
81  
82      static String uriPattern( String subPath )
83      {
84          return "http://.*/[0-9]+" + subPath;
85      }
86  
87      public static Map<String, Object> serialize( MappingRepresentation repr )
88      {
89          Map<String, Object> result = new HashMap<String, Object>();
90          repr.serialize( new MappingSerializer( new MapWrappingWriter( result ), BASE_URI, null ) );
91          return result;
92      }
93  
94      public static List<Object> serialize( ListRepresentation repr )
95      {
96          List<Object> result = new ArrayList<Object>();
97          repr.serialize( new ListSerializer( new ListWrappingWriter( result ), BASE_URI, null ) );
98          return result;
99      }
100 
101     private static class StringFormat extends RepresentationFormat
102     {
103         StringFormat()
104         {
105             super( MediaType.WILDCARD_TYPE );
106         }
107 
108         @Override
109         protected String serializeValue( String type, Object value )
110         {
111             return value.toString();
112         }
113 
114         @Override
115         protected String complete( ListWriter serializer )
116         {
117             throw new UnsupportedOperationException( "StringFormat.complete(ListWriter)" );
118         }
119 
120         @Override
121         protected String complete( MappingWriter serializer )
122         {
123             throw new UnsupportedOperationException( "StringFormat.complete(MappingWriter)" );
124         }
125 
126         @Override
127         protected ListWriter serializeList( String type )
128         {
129             throw new UnsupportedOperationException( "StringFormat.serializeList()" );
130         }
131 
132         @Override
133         protected MappingWriter serializeMapping( String type )
134         {
135             throw new UnsupportedOperationException( "StringFormat.serializeMapping()" );
136         }
137 
138         @Override
139         public List<Object> readList( String input )
140         {
141             throw new UnsupportedOperationException( "StringFormat.readList()" );
142         }
143 
144         @Override
145         public Map<String, Object> readMap( String input )
146         {
147             throw new UnsupportedOperationException( "StringFormat.readMap()" );
148         }
149 
150         @Override
151         public Object readValue( String input )
152         {
153             throw new UnsupportedOperationException( "StringFormat.readValue()" );
154         }
155 
156         @Override
157         public URI readUri( String input )
158         {
159             throw new UnsupportedOperationException( "StringFormat.readUri()" );
160         }
161     }
162 }