apiture 0.2.0

data/lib/apiture/swagger/security.rb

@@ -0,0 +1,21 @@
+require 'apiture/swagger/node'
+
+module Apiture
+  module Swagger
+    class Security < Node
+      attr_reader :id
+
+      attribute :scopes
+
+      def initialize(id)
+        super()
+        @id = id
+      end
+
+      def serializable_hash
+        scopes || []
+      end
+
+    end
+  end
+end

data/lib/apiture/swagger/security_definition.rb

@@ -0,0 +1,23 @@
+require 'apiture/swagger/node'
+
+module Apiture
+  module Swagger
+    class SecurityDefinition < Node
+      attr_reader :id
+
+      attribute :type
+      attribute :description
+      attribute :name
+      attribute :in, symbolize: true
+      attribute :flow
+      attribute :authorization_url
+      attribute :token_url
+      attribute :scopes
+
+      def initialize(id)
+        super()
+        @id = id
+      end
+    end
+  end
+end

data/lib/apiture/swagger/specification.rb

@@ -0,0 +1,31 @@
+require 'apiture/swagger/info'
+require 'apiture/swagger/external_docs'
+require 'apiture/swagger/security'
+require 'apiture/swagger/security_definition'
+require 'apiture/swagger/path'
+require 'apiture/swagger/definition'
+# require 'apiture/swagger/response'
+
+module Apiture
+  module Swagger
+    class Specification < Node
+      attribute :swagger
+      attribute :info, validate: true
+      attribute :host
+      attribute :base_path
+      attribute :external_docs, validate: true
+
+      list :schemes
+      list :consumes
+      list :produces
+      list :tags, validate: true
+
+      hash :paths, validate: true
+      hash :definitions, validate: true
+      hash :parameters, validate: true
+      hash :responses, validate: true
+      hash :security_definitions, validate: true
+      hash :security, validate: true
+    end
+  end
+end

data/lib/apiture/uri.rb

@@ -0,0 +1,36 @@
+module Apiture
+  class URI
+
+    components = [:scheme, :host, :base_host, :subdomain, :base_path, :resource_path]
+
+    attr_reader *components
+
+    components.each do |comp|
+      define_method "#{comp}=".to_sym do |v|
+        instance_variable_set("@#{comp}", v)
+        build_url
+      end
+    end
+
+    def to_s
+      build_url
+    end
+
+    protected
+
+      def build_url
+        host = if base_host && subdomain
+                 [subdomain, base_host].join('.')
+               else
+                 self.host
+               end
+        [
+          scheme,
+          '://',
+          host,
+          base_path,
+          resource_path
+        ].join('')
+      end
+  end
+end

data/lib/apiture/utils/inflections.rb

@@ -0,0 +1,46 @@
+module Apiture
+  module Utils
+    module Inflections
+
+      def self.acronyms
+        @@acronyms ||= {}
+      end
+
+      def self.acronym_regex
+        @@acronym_regex ||= /(?=a)b/
+      end
+
+      def camelize(term, uppercase_first_letter = true)
+        string = term.to_s
+        if uppercase_first_letter
+          string = string.sub(/^[a-z\d]*/) { ::Apiture::Utils::Inflections.acronyms[$&] || $&.capitalize }
+        else
+          string = string.sub(/^(?:#{::Apiture::Utils::Inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { $&.downcase }
+        end
+        string.gsub!(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{::Apiture::Utils::Inflections.acronyms[$2] || $2.capitalize}" }
+        string.gsub!('/', '::')
+        string
+      end
+
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.gsub('::', '/')
+        word.gsub!(/(?:([A-Za-z\d])|^)(#{::Apiture::Utils::Inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      def constantize(camel_cased_word)
+        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+          raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+        end
+
+        Object.module_eval("::#{$1}", __FILE__, __LINE__)
+      end
+    end
+  end
+end
+
+Apiture::Utils::Inflections.extend(Apiture::Utils::Inflections)

data/lib/apiture/version.rb

@@ -0,0 +1,3 @@
+module Apiture
+  VERSION = "0.2.0"
+end

data/spec/apiture/api_builder_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'apiture'
+
+describe Apiture::APIBuilder do
+
+  def build_spec(name)
+    Apiture.parse_specification(File.join(File.dirname(__FILE__), '..', 'files', "#{name}.json"))
+  end
+
+  it "should build a API class from specification" do
+    api = Apiture::APIBuilder.new(build_spec("pivotal_tracker")).build
+    expect(api).to_not be_nil
+  end
+
+  it "should build a API class from specification" do
+    api = Apiture::APIBuilder.new(build_spec("mandrill")).build
+    expect(api).to_not be_nil
+  end
+
+end

data/spec/apiture/swagger/parser_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'apiture/swagger/parser'
+
+describe Apiture::Swagger::Parser do
+  subject { Apiture::Swagger::Parser }
+
+  def load_spec(name)
+    File.read(File.join(File.dirname(__FILE__), '..', '..', 'files', "#{name}.json"))
+  end
+
+  it "should parse a swagger specification" do
+    specification = Apiture::Swagger::Parser.new.parse(load_spec('pivotal_tracker'))
+    expect(specification).to_not be_nil
+
+    expect(specification.host).to eq "www.pivotaltracker.com"
+    expect(specification.schemes).to include "https"
+    expect(specification.base_path).to eq "/services/v5"
+
+    expect(specification.info).to_not be_nil
+    expect(specification.info.title).to eq "PivotalTracker"
+    expect(specification.info.version).to eq "5"
+
+    api_token = specification.security_definitions['apiToken']
+    expect(api_token).to_not be_nil
+    expect(api_token.type).to eq "apiKey"
+    expect(api_token.in).to eq :header
+    expect(api_token.name).to eq "X-TrackerToken"
+
+    security = specification.security['apiToken']
+    expect(security).to_not be_nil
+
+    expect(specification.produces).to include "application/json"
+
+    expect(specification.paths.count).to eq 1
+
+    path = specification.paths["/projects/{projectId}/stories"]
+    expect(path).to_not be_nil
+
+    expect(path.post).to_not be_nil
+    expect(path.post.operation_id).to eq "createStory"
+    expect(path.post.external_docs.url).to eq "https://www.pivotaltracker.com/help/api/rest/v5#projects_project_id_stories_post"
+
+    expect(path.post.parameters.count).to eq 2
+
+    param1 = path.post.parameters[0]
+    expect(param1).to_not be_nil
+    expect(param1.in).to eq :path
+    expect(param1.name).to eq "projectId"
+    expect(param1).to be_required
+
+    param2 = path.post.parameters[1]
+    expect(param2).to_not be_nil
+    expect(param2.in).to eq :body
+    expect(param2.name).to eq "story"
+    expect(param2).to be_required
+    expect(param2.schema).to eq "NewStory"
+
+    expect(specification.definitions.count).to eq 1
+
+    definition = specification.definitions["NewStory"]
+    expect(definition).to_not be_nil
+    expect(definition.required).to eq ["name"]
+
+    expect(definition.properties.count).to eq 15
+
+    prop1 = definition.properties["cl_numbers"]
+    expect(prop1).to_not be_nil
+    expect(prop1.type).to eq :string
+
+    prop2 = definition.properties["current_state"]
+    expect(prop2).to_not be_nil
+    expect(prop2.type).to eq :string
+    expect(prop2.enum).to eq [
+      "accepted",
+      "delivered",
+      "finished",
+      "started",
+      "rejected",
+      "unstarted",
+      "unscheduled"
+    ]
+  end
+
+  it "should parse a swagger specification with an array of schema objects" do
+    specification = Apiture::Swagger::Parser.new.parse(load_spec('slack'))
+    payload = specification.definitions["Payload"]
+
+    attachments_prop = payload.properties['attachments']
+    expect(attachments_prop.type).to eq :array
+    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 = Apiture::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 = Apiture::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 Apiture::Swagger::Definition
+  end
+end

data/spec/apiture/swagger/specification_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'apiture/swagger/specification'
+
+describe Apiture::Swagger::Specification do
+
+  it "should serialize security node as key and scopes" do
+    spec = described_class.new
+
+    security = Apiture::Swagger::Security.new('oauth')
+    security.scopes = ['email']
+    spec.security = { 'oauth' => security }
+
+    hash = spec.serializable_hash
+    security_hash = hash['security'] 
+    expect(security_hash).to_not be_nil
+    scopes = security_hash['oauth']
+    expect(scopes).to eq ['email']
+  end
+end

data/spec/apiture_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+require 'apiture'
+require 'logger'
+
+describe Apiture 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")
+    Apiture.load_api(fn)
+  end
+
+  describe do
+    let(:parser) { double("parser") }
+
+    before do
+      allow(File).to receive(:read)
+      expect(Apiture::Swagger::Parser).to receive(:new).and_return(parser)
+    end
+
+    it "should auto-detect whether it is parsing YAML file" do
+      expect(parser).to receive(:parse_yaml)
+      Apiture.parse_specification("foo.yml")
+    end
+
+    it "should auto-detect whether it is parsing JSON file" do
+      expect(parser).to receive(:parse_json)
+      Apiture.parse_specification("foo.json")
+    end
+  end
+
+  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.body['kind']).to eq 'story'
+        expect(result.body).to have_key('id')
+        expect(result.status).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.body['results'].first).to have_key('project_id')
+        expect(results.status).to eq 200
+      end
+    end
+  end
+
+  describe "Slack API" do
+    before do
+      Slack = load_api('slack')
+      @client = configure_client(Slack.new)
+    end
+
+    after do
+      Object.send(:remove_const, :Slack)
+    end
+
+    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.status).to eq 200
+        expect(results.body).to eq "ok"
+      end
+    end
+  end
+
+  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.status).to eq 200
+        expect(results.body['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: "afaketoken"
+        )
+        expect(results.status).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.status).to eq 200
+        expect(results.body["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.body).to eq "PONG!"
+      end
+    end
+
+    it "should be able to build request with apiKey and parameters in JSON body" do
+      VCR.use_cassette('mandrill_messageSend') do
+        result = @client.message_send(request: {
+          message: {
+            text: "testing",
+            subject: "testing",
+            from_email: "test@test.com",
+            to: [ { email: "test@example.com" } ]
+          }
+        }).body
+        expect(result.first["email"]).to eq "test@example.com"
+        expect(result.first["status"]).to eq "sent"
+      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 support x-base-host extension" do
+      VCR.use_cassette('harvest_invoiceList') do
+        result = @client.invoice_list.body
+        expect(result.length).to eq 2
+      end
+    end
+  end
+end