Want more features on Pastebin? Sign Up, it's FREE!
Guest

Erem Boto

By: a guest on Apr 28th, 2010  |  syntax: Groovy  |  size: 4.11 KB  |  views: 344  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
This paste has a previous version, view the difference. Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1.  
  2. import groovyx.net.http.HTTPBuilder;
  3.  
  4. import org.junit.runner.RunWith;
  5. import org.scribe.oauth.Scribe;
  6. import org.scribe.oauth.Token
  7.  
  8. import spock.lang.Specification;
  9. import spock.lang.Sputnik;
  10.  
  11. @RunWith(Sputnik)
  12. public class OAuthHttpBuilderTest extends Specification {
  13.         HTTPBuilder delegate = Mock()
  14.         Scribe signer
  15.         Token tok
  16.        
  17.         OAuthHttpBuilder underTest
  18.        
  19.         def uri
  20.        
  21.         def setup() {
  22.                 Properties props = new Properties([    "consumer.key" : "myClientKey",
  23.                                                     "consumer.secret" : "myClientSecret" ])
  24.                 signer = new Scribe(props);
  25.                 tok = new Token("token_key", "token_secret")
  26.                 underTest = new OAuthHttpBuilder(delegate, signer)
  27.         }
  28.        
  29.         def "Null token passes Scribe a token with empty token/secret"() {
  30.                 given:
  31.                 signer = Mock(Scribe)
  32.                 delegate.getUri() >> (uri = "http://localhost:8080/users/1")
  33.                
  34.                 when:
  35.                 underTest = new OAuthHttpBuilder(delegate, signer)
  36.                 underTest.get(query: null)
  37.                
  38.                 then:
  39.                 1 * signer.signRequest(_,_) >> { scribeReq, token ->
  40.                         assert token.token == ""
  41.                         assert token.secret == ""
  42.                 }
  43.         }
  44.        
  45.         def "Signs and passes authorization header in GET method"() {
  46.                 given:
  47.                 delegate.getUri() >> (uri = "http://localhost:8080/users/1")
  48.                
  49.                 when:
  50.                 underTest.get(query: null, accessToken: tok)
  51.                
  52.                 then:
  53.                 1 * delegate.get(_) >> { args -> argsHaveAuthorizationString(args) }
  54.         }
  55.        
  56.         def "Passes authorization header in GET method with default access token"() {
  57.                 given:
  58.                 delegate.getUri() >> (uri = "http://localhost:8080/users/1")
  59.                 underTest.setAccessToken(tok)
  60.                
  61.                 when:
  62.                 underTest.get(query: null)
  63.                
  64.                 then:
  65.                 1 * delegate.get(_) >> { args -> argsHaveAuthorizationString(args) }
  66.         }
  67.        
  68.         def "Passes authorization header in POST method"() {
  69.                 given:
  70.                 delegate.getUri() >> (uri = "http://localhost:8080/users/1")
  71.                
  72.                 when:
  73.                 underTest.post(body: null, accessToken: tok)
  74.                
  75.                 then:
  76.                 1 * delegate.post(_) >> { args -> argsHaveAuthorizationString(args) }
  77.         }
  78.        
  79.         def "Provides query params for GET requests"() {
  80.                 given:
  81.                 signer = Mock(Scribe)
  82.                 delegate.getUri() >> (uri = "http://localhost:8080/users/1")
  83.                 def queryParams = [a: "b", c: "d"]
  84.                                    
  85.                 when:
  86.                 underTest = new OAuthHttpBuilder(delegate, signer)
  87.                 underTest.get(query: queryParams, accessToken: tok)
  88.                
  89.                 then:
  90.                 1 * signer.signRequest(_,tok) >> { scribeReq, token ->
  91.                         def bodyParams = scribeReq.getBodyParams()
  92.                         assert bodyParams.size() == 2
  93.                         bodyParams.each { entry ->
  94.                                 assert queryParams[entry.key] == entry.value
  95.                         }
  96.                         scribeReq.addHeader("Authorization", "sure you're authorized why not")
  97.                 }
  98.         }
  99.        
  100.         def "Provides query params and body params for POST requests"() {
  101.                 given:
  102.                 signer = Mock(Scribe)
  103.                 delegate.getUri() >> (uri = "http://localhost:8080/users/1")
  104.                 def queryParams = [a: "b", c: "d"]
  105.                 def bodyParams = [e: "f", g: "h"]
  106.                                  
  107.                 when:
  108.                 underTest = new OAuthHttpBuilder(delegate, signer)
  109.                 underTest.post(query: queryParams, body: bodyParams, accessToken: tok)
  110.                
  111.                 then:
  112.                 1 * signer.signRequest(_,tok) >> { scribeReq, token ->
  113.                         def passedBodyParams = scribeReq.getBodyParams()
  114.                         assert passedBodyParams.size() == 4
  115.                         bodyParams.each { entry ->
  116.                                 assert (queryParams[entry.key] == entry.value) ||
  117.                                 (bodyParams[entry.key] == entry.value)
  118.                         }
  119.                         scribeReq.addHeader("Authorization", "sure you're authorized why not")
  120.                 }
  121.         }
  122.        
  123.         def "Handles integer inputs fine"() {
  124.                 given:
  125.                 signer = Mock(Scribe)
  126.                 delegate.getUri() >> (uri = "http://localhost:8080/users/1")
  127.                 def queryParams = [aNumber: 1]
  128.                 underTest = new OAuthHttpBuilder(delegate, signer)
  129.                
  130.                 when:
  131.                 underTest.get(query: queryParams, accessToken: tok)
  132.                
  133.                 then:
  134.                 1 * signer.signRequest(_, tok) >> { scribeReq, token ->
  135.                         def passedBodyParams = scribeReq.getBodyParams()
  136.                         assert passedBodyParams.size() == 1
  137.                         passedBodyParams.each { entry ->
  138.                                 assert entry.value == "1"
  139.                         }
  140.                 }
  141.         }
  142.        
  143.         /*
  144.          * Private Methods
  145.          */
  146.         def argsHaveAuthorizationString(args) {
  147.                 assert args.headers.size() != 0
  148.                 assert args.headers.Authorization.size() == 1
  149.                 assert args.headers.Authorization[0] != null
  150.         }
  151. }
clone this paste RAW Paste Data