import groovyx.net.http.HTTPBuilder;

import org.junit.runner.RunWith;
import org.scribe.oauth.Scribe;
import org.scribe.oauth.Token 

import spock.lang.Specification;
import spock.lang.Sputnik;

@RunWith(Sputnik)
public class OAuthHttpBuilderTest extends Specification {
	HTTPBuilder delegate = Mock()
	Scribe signer
	Token tok
	
	OAuthHttpBuilder underTest
	
	def uri
	
	def setup() {
		Properties props = new Properties([    "consumer.key" : "myClientKey", 
		                                    "consumer.secret" : "myClientSecret" ])
		signer = new Scribe(props);
		tok = new Token("token_key", "token_secret")
		underTest = new OAuthHttpBuilder(delegate, signer)
	}
	
	def "Null token passes Scribe a token with empty token/secret"() {
		given:
		signer = Mock(Scribe)
		delegate.getUri() >> (uri = "http://localhost:8080/users/1")
		
		when:
		underTest = new OAuthHttpBuilder(delegate, signer)
		underTest.get(query: null)
		
		then:
		1 * signer.signRequest(_,_) >> { scribeReq, token ->
			assert token.token == ""
			assert token.secret == ""
		}
	}
	
	def "Signs and passes authorization header in GET method"() {
		given:
		delegate.getUri() >> (uri = "http://localhost:8080/users/1")
		
		when:
		underTest.get(query: null, accessToken: tok)
		
		then:
		1 * delegate.get(_) >> { args -> argsHaveAuthorizationString(args) }
	}
	
	def "Passes authorization header in GET method with default access token"() {
		given:
		delegate.getUri() >> (uri = "http://localhost:8080/users/1")
		underTest.setAccessToken(tok)
		
		when:
		underTest.get(query: null)
		
		then:
		1 * delegate.get(_) >> { args -> argsHaveAuthorizationString(args) }
	}
	
	def "Passes authorization header in POST method"() {
		given:
		delegate.getUri() >> (uri = "http://localhost:8080/users/1")
		
		when:
		underTest.post(body: null, accessToken: tok)
		
		then:
		1 * delegate.post(_) >> { args -> argsHaveAuthorizationString(args) }
	}
	
	def "Provides query params for GET requests"() {
		given:
		signer = Mock(Scribe)
		delegate.getUri() >> (uri = "http://localhost:8080/users/1")
		def queryParams = [a: "b", c: "d"]
		                   
		when:
		underTest = new OAuthHttpBuilder(delegate, signer)
		underTest.get(query: queryParams, accessToken: tok)
		
		then:
		1 * signer.signRequest(_,tok) >> { scribeReq, token ->
			def bodyParams = scribeReq.getBodyParams()
			assert bodyParams.size() == 2
			bodyParams.each { entry ->
				assert queryParams[entry.key] == entry.value
			}
			scribeReq.addHeader("Authorization", "sure you're authorized why not")
		}
	}
	
	def "Provides query params and body params for POST requests"() {
		given:
		signer = Mock(Scribe)
		delegate.getUri() >> (uri = "http://localhost:8080/users/1")
		def queryParams = [a: "b", c: "d"]
		def bodyParams = [e: "f", g: "h"]
		                  
		when:
		underTest = new OAuthHttpBuilder(delegate, signer)
		underTest.post(query: queryParams, body: bodyParams, accessToken: tok)
		
		then:
		1 * signer.signRequest(_,tok) >> { scribeReq, token ->
			def passedBodyParams = scribeReq.getBodyParams()
			assert passedBodyParams.size() == 4
			bodyParams.each { entry ->
				assert (queryParams[entry.key] == entry.value) ||
				(bodyParams[entry.key] == entry.value)
			}
			scribeReq.addHeader("Authorization", "sure you're authorized why not")
		}
	}
	
	def "Handles integer inputs fine"() {
		given:
		signer = Mock(Scribe)
		delegate.getUri() >> (uri = "http://localhost:8080/users/1")
		def queryParams = [aNumber: 1]
		underTest = new OAuthHttpBuilder(delegate, signer)
		
		when:
		underTest.get(query: queryParams, accessToken: tok)
		
		then:
		1 * signer.signRequest(_, tok) >> { scribeReq, token ->
			def passedBodyParams = scribeReq.getBodyParams()
			assert passedBodyParams.size() == 1
			passedBodyParams.each { entry ->
				assert entry.value == "1"
			}
		}
	}
	
	/*
	 * Private Methods
	 */
	def argsHaveAuthorizationString(args) {
		assert args.headers.size() != 0
		assert args.headers.Authorization.size() == 1
		assert args.headers.Authorization[0] != null
	}
}