Erem Boto

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
    }
}