diesel-api-dsl 0.1.3 → 0.1.5

data/lib/diesel/version.rb

@@ -1,3 +1,3 @@
 module Diesel
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/spec/diesel/api_builder_spec.rb

@@ -3,12 +3,18 @@ require 'diesel'
 
 describe Diesel::APIBuilder do
 
-  let(:specification) do
-    Diesel.parse_specification(File.join(File.dirname(__FILE__), '..', 'files', 'pivotal_tracker.json'))
+  def build_spec(name)
+    Diesel.parse_specification(File.join(File.dirname(__FILE__), '..', 'files', "#{name}.json"))
   end
 
   it "should build a API class from specification" do
-    api = Diesel::APIBuilder.new(specification).build
+    api = Diesel::APIBuilder.new(build_spec("pivotal_tracker")).build
+    expect(api).to_not be_nil
+  end
+
+  it "should build a API class from specification" do
+    api = Diesel::APIBuilder.new(build_spec("mandrill")).build
+    expect(api).to_not be_nil
   end
 
 end

data/spec/diesel/swagger/parser_spec.rb

@@ -90,4 +90,18 @@ describe Diesel::Swagger::Parser do
     expect(attachments_prop.items.count).to eq 1
     expect(attachments_prop.items["$ref"]).to eq '#/definitions/Attachment'
   end
+
+  it "should parse a swagger specification with operation specific security" do
+    specification = Diesel::Swagger::Parser.new.parse(load_spec('github'))
+    op = specification.paths["/applications/{clientId}/tokens/{accessToken}"].get
+    expect(op.security["basic"]).to_not be_nil
+  end
+
+  it "should parse nested schema objects" do
+    specification = Diesel::Swagger::Parser.new.parse(load_spec('mandrill'))
+    op = specification.paths["/messages/send.json"].post
+    request_param = op.parameters.first
+    expect(specification.consumes).to include "application/json"
+    expect(request_param.schema.class).to eq Diesel::Swagger::Definition
+  end
 end

data/spec/diesel_spec.rb

@@ -4,74 +4,191 @@ require 'logger'
 
 describe Diesel do
 
+  def configure_client(client)
+    #client.logger = Logger.new(STDOUT)
+    #client.logger.level = Logger::DEBUG
+    client
+  end
+
   def load_api(name)
     fn = File.join(File.dirname(__FILE__), 'files', "#{name}.json")
     Diesel.load_api(fn)
   end
 
-  it "should be able to build a PivotalTracker API client" do
-    PivotalTracker = load_api('pivotal_tracker')
-    client = PivotalTracker.new(api_token: 'afaketoken')
-    client.logger = Logger.new(STDOUT)
-    client.logger.level = Logger::DEBUG
-
-    VCR.use_cassette('pivotal_tracker_create_story') do
-      result = client.create_story(
-        project_id: '1053124',
-        story: {
-          name: 'Testing Pivotal API',
-          story_type: :chore
-        })
-      expect(result['kind']).to eq 'story'
-      expect(result).to have_key('id')
-      expect(result.response.code).to eq "200"
+  describe "Pivotal Tracker API" do
+    before do
+      PivotalTracker = load_api('pivotal_tracker')
+      @client = configure_client(PivotalTracker.new(api_token: 'afaketoken'))
+    end
+
+    after do
+      Object.send(:remove_const, :PivotalTracker)
+    end
+
+    it "should be able to build a client" do
+      VCR.use_cassette('pivotal_tracker_create_story') do
+        result = @client.create_story(
+          project_id: '1053124',
+          story: {
+            name: 'Testing Pivotal API',
+            story_type: :chore
+          })
+        expect(result['kind']).to eq 'story'
+        expect(result).to have_key('id')
+        expect(result.response.code).to eq "200"
+      end
+    end
+  end
+
+  describe "Honeybadger API" do
+    before do
+      Honeybadger = load_api('honeybadger')
+      @client = configure_client(Honeybadger.new(auth_token: 'afaketoken'))
+    end
+
+    after do
+      Object.send(:remove_const, :Honeybadger)
+    end
+
+    it "should be able to build a Honeybadger API client" do
+      VCR.use_cassette('honeybadger') do
+        results = @client.get_faults(project_id: 3167)
+        expect(results['results'].first).to have_key('project_id')
+        expect(results.response.code).to eq "200"
+      end
     end
   end
 
-  it "should be able to build a Honeybadger API client" do
-    Honeybadger = load_api('honeybadger')
-    client = Honeybadger.new(auth_token: 'afaketoken')
-    client.logger = Logger.new(STDOUT)
-    client.logger.level = Logger::DEBUG
+  describe "Slack API" do
+    before do
+      Slack = load_api('slack')
+      @client = configure_client(Slack.new)
+    end
+
+    after do
+      Object.send(:remove_const, :Slack)
+    end
 
-    VCR.use_cassette('honeybadger') do
-      results = client.get_faults(project_id: 3167)
-      expect(results['results'].first).to have_key('project_id')
-      expect(results.response.code).to eq "200"
+    it "should be able to build a Slack API client" do
+      VCR.use_cassette('slack') do
+        results = @client.post_message(path: 'abcd/efgh/ijkl',
+                                       payload: {
+                                         text: 'Testing',
+                                         username: 'TestBot',
+                                         attachments: [{
+                                           fallback: "test fallback text",
+                                           text: "test text",
+                                           pretext: "test pretext",
+                                           fields: [{
+                                             title: "test field 1",
+                                             value: "test value 1"
+                                           },{
+                                             title: "test field 2",
+                                             value: "test value 2"
+                                           }]
+                                         }]
+                                       })
+        expect(results.response.code).to eq "200"
+        expect(results.parsed_response).to eq "ok"
+      end
     end
   end
 
-  it "should be able to build a Slack API client" do
-    Slack = load_api('slack')
-    client = Slack.new
-    client.logger = Logger.new(STDOUT)
-    client.logger.level = Logger::DEBUG
-
-    VCR.use_cassette('slack') do
-      results = client.post_message(path: 'abcd/efgh/ijkl',
-                                    payload: {
-                                      text: 'Testing',
-                                      username: 'TestBot',
-                                      attachments: [
-                                        {
-                                          fallback: "test fallback text",
-                                          text: "test text",
-                                          pretext: "test pretext",
-                                          fields: [
-                                            {
-                                              title: "test field 1",
-                                              value: "test value 1"
-                                            },
-                                            {
-                                              title: "test field 2",
-                                              value: "test value 2"
-                                            }
-                                          ]
-                                        }
-                                      ]
-                                    })
-      expect(results.response.code).to eq "200"
-      expect(results.parsed_response).to eq "ok"
+  describe "Github API" do
+    before do
+      Github = load_api("github")
+      @client = configure_client(Github.new(
+        oauth2: { token: "afaketoken" },
+        basic: {
+          username: "afakeclientid",
+          password: "afakeclientsecret"
+        }
+      ))
+    end
+
+    after do
+      Object.send(:remove_const, :Github)
+    end
+
+    it "should be able to call a zero parameter operation" do
+      VCR.use_cassette('github_getUser') do
+        results = @client.get_user
+        expect(results.response.code).to eq "200"
+        expect(results.parsed_response['login']).to eq "cyu"
+      end
+    end
+
+    it "should be able to use the appropriate security scheme" do
+      VCR.use_cassette('github_checkAuthorization') do
+        results = @client.check_authorization(
+          client_id: "afakeclientid",
+          access_token: "afakeaccesstoken"
+        )
+        expect(results.response.code).to eq "200"
+      end
+    end
+  end
+
+  describe "Uber API" do
+    before do
+      Uber = load_api("uber")
+      @client = configure_client(Uber.new(
+        server_token: "TEST_SERVER_TOKEN"
+      ))
+    end
+
+    after do
+      Object.send(:remove_const, :Uber)
+    end
+
+    it "should be able to support x-format extension for apiKey" do
+      VCR.use_cassette('uber_getProducts') do
+        results = @client.get_products(latitude: 33.776776, longitude: -84.389683)
+        expect(results.response.code).to eq "200"
+        expect(results.parsed_response["products"].length).to eq 5
+      end
+    end
+  end
+
+  describe "Mandrill API" do
+    before do
+      Mandrill = load_api("mandrill")
+      @client = configure_client(Mandrill.new(
+        key: "fakekey"
+      ))
+    end
+
+    after do
+      Object.send(:remove_const, :Mandrill)
+    end
+
+    it "should be able to support apiKey in JSON body" do
+      VCR.use_cassette('mandrill_userPing') do
+        result = @client.user_ping
+        expect(result.parsed_response).to eq "PONG!"
+      end
+    end
+  end
+
+  describe "Harvest API" do
+    before do
+      Harvest = load_api("harvest")
+      @client = configure_client(Harvest.new(
+        subdomain: "fakedomain",
+        oauth2: {
+          token: "faketoken"
+        }))
+    end
+
+    after do
+      Object.send(:remove_const, :Harvest)
+    end
+
+    it "should be able to x-base-host extension" do
+      VCR.use_cassette('harvest_invoiceList') do
+        result = @client.invoice_list
+        expect(result.length).to eq 2
+      end
     end
   end
 end

data/spec/files/github.json

@@ -0,0 +1,186 @@
+{
+  "swagger": "2.0",
+
+  "info": {
+    "title": "Github",
+    "version": "3"
+  },
+
+  "host": "api.github.com",
+
+  "basePath": "/",
+
+  "schemes": ["https"],
+
+  "produces": ["application/json"],
+
+  "securityDefinitions": {
+    "oauth2": {
+      "type": "oauth2",
+      "flow": "accessCode",
+      "authorizationUrl": "https://github.com/login/oauth/authorize",
+      "tokenUrl": "https://github.com/login/oauth/access_token",
+      "scopes": {
+        "user": "Grants read/write access to profile info only.",
+        "user:email": "Grants read access to a user’s email addresses.",
+        "user:follow": "Grants access to follow or unfollow other users.",
+        "public_repo": "Grants read/write access to code, commit statuses, collaborators, and deployment statuses for public repositories and organizations.",
+        "repo": "Grants read/write access to code, commit statuses, collaborators, and deployment statuses for public and private repositories and organizations.",
+        "repo_deployment": "Grants access to deployment statuses for public and private repositories.",
+        "repo:status": "Grants read/write access to public and private repository commit statuses.",
+        "delete_repo": "Grants access to delete adminable repositories.",
+        "notifications": "Grants read access to a user’s notifications.",
+        "gist": "Grants write access to gists.",
+        "read:repo_hook": "Grants read and ping access to hooks in public or private repositories.",
+        "write:repo_hook": "Grants read, write, and ping access to hooks in public or private repositories.",
+        "admin:repo_hook": "Grants read, write, ping, and delete access to hooks in public or private repositories.",
+        "admin:org_hook": "Grants read, write, ping, and delete access to organization hooks.",
+        "read:org": "Read-only access to organization, teams, and membership.",
+        "write:org": "Publicize and unpublicize organization membership.",
+        "admin:org": "Fully manage organization, teams, and memberships.",
+        "read:public_key": "List and view details for public keys.",
+        "write:public_key": "Create, list, and view details for public keys.",
+        "admin:public_key": "Fully manage public keys."
+      }
+    },
+    "basic": {
+      "type": "basic"
+    }
+  },
+
+  "security": {
+    "oauth2": []
+  },
+
+  "paths": {
+    "/user": {
+      "get": {
+        "summary": "Get the authenticated user",
+        "operationId": "getUser"
+      }
+    },
+    "/user/emails": {
+      "get": {
+        "summary": "List email addresses for a user",
+        "operationId": "getUserEmails",
+        "security": {
+          "basic": ["user:email"]
+        }
+      }
+    },
+    "/user/repos": {
+      "get": {
+        "summary": "List repositories that are accessible to the authenticated user.",
+        "operationId": "getUserRepos",
+        "parameters": [{
+          "name": "visibility",
+          "in": "query",
+          "enum": [
+            "all",
+            "public",
+            "private"
+          ]
+        }, {
+          "name": "affiliation",
+          "in": "query"
+        }, {
+          "name": "type",
+          "in": "query",
+          "enum": [
+            "all",
+            "owner",
+            "public",
+            "private",
+            "member"
+          ]
+        }, {
+          "name": "sort",
+          "in": "query",
+          "enum": [
+            "created",
+            "updated",
+            "pushed",
+            "full_name"
+          ]
+        }, {
+          "name": "direction",
+          "in": "query",
+          "enum": [
+            "asc",
+            "desc"
+          ]
+        }]
+      }
+    },
+    "/user/orgs": {
+      "get": {
+        "summary": "List organizations for the authenticated user",
+        "operationId": "getUserOrgs",
+        "security": {
+          "oauth2": [
+            "user",
+            "read:org"
+          ]
+        }
+      }
+    },
+    "/orgs/{org}/repos": {
+      "get": {
+        "summary": "List repositories for the specified org",
+        "operationId": "getOrgRepos",
+        "parameters": [{
+          "name": "org",
+          "in": "path",
+          "required": true
+        }, {
+          "name": "type",
+          "in": "query",
+          "enum": [
+            "all",
+            "public",
+            "private",
+            "forks",
+            "sources",
+            "member"
+          ]
+        }]
+      }
+    },
+    "/repos/{owner}/{repo}/issues/{number}": {
+      "get": {
+        "summary": "Get a single issue",
+        "operationId": "getIssue",
+        "parameters": [{
+          "name": "owner",
+          "in": "path",
+          "required": true
+        },{
+          "name": "repo",
+          "in": "path",
+          "required": true
+        },{
+          "name": "number",
+          "in": "path",
+          "required": true
+        }]
+      }
+    },
+    "/applications/{clientId}/tokens/{accessToken}": {
+      "get": {
+        "operationId": "checkAuthorization",
+        "parameters": [{
+          "name": "clientId",
+          "in": "path",
+          "required": true
+        },{
+          "name": "accessToken",
+          "in": "path",
+          "required": true
+        }],
+        "security": {
+          "basic": []
+        }
+      }
+    }
+  }
+}