twimock 0.0.1

data/lib/twimock/user.rb

@@ -0,0 +1,58 @@
+require 'faker'
+require 'twimock/database/table'
+require 'twimock/access_token'
+require 'twimock/request_token'
+
+module Twimock
+  # TODO: 要改善 AccessTokenをUserから分離
+  class User < Database::Table
+    TABLE_NAME = :users
+    COLUMN_NAMES = [:id, :name, :twitter_id, :email, :password, :created_at]
+    CHILDREN = [ Twimock::AccessToken, Twimock::RequestToken ]
+    INFO_KEYS = [:id, :name, :created_at]
+
+    def initialize(options={})
+      opts = Hashie::Mash.new(options)
+      id = opts.id || opts.identifier
+      @id                  = (id.to_i > 0) ? id.to_i : (Faker::Number.number(10)).to_i
+      @name                = opts.name                || create_user_name
+      @twitter_id          = opts.twitter_id          || @name.downcase.gsub(" ", "_")
+      @email               = opts.email               || Faker::Internet.email
+      @password            = opts.password            || Faker::Internet.password
+      @created_at     = opts.created_at
+    end
+
+    def info
+      info_hash = Hashie::Mash.new({})
+      INFO_KEYS.each { |key| info_hash[key] = self.instance_variable_get("@#{key}") }
+      info_hash.id_str = info_hash.id.to_s
+      info_hash
+    end
+
+    def generate_access_token(application_id=nil)
+      if application_id
+        application = Twimock::Application.find_by_id(application_id)
+        raise Twimock::Errors::ApplicationNotFound unless application
+      end
+
+      access_token = Twimock::AccessToken.new({ application_id: application_id })
+      if self.persisted?
+        access_token.user_id = self.id
+        access_token.save!
+      end
+      access_token
+    end
+
+    def self.find_by_tiwtter_id_or_email(value)
+      user   = Twimock::User.find_by_twitter_id(value)
+      user ||= Twimock::User.find_by_email(value)
+    end
+
+    private
+
+    def create_user_name
+      n = Faker::Name.name
+      (n.include?("'") || n.include?(".")) ? create_user_name : n
+    end
+  end
+end

data/lib/twimock/version.rb

@@ -0,0 +1,3 @@
+module Twimock
+  VERSION = "0.0.1"
+end

data/lib/twimock.rb

@@ -0,0 +1,39 @@
+require "active_support/time"
+require "twimock/version"
+require "twimock/database"
+require "twimock/config"
+require "twimock/application"
+require "twimock/user"
+require "twimock/access_token"
+require "twimock/request_token"
+require "twimock/auth_hash"
+require "twimock/errors"
+require "twimock/api"
+require "twimock/omniauth_twitter"
+
+module Twimock
+  extend self
+
+  def auth_hash(access_token_string=nil)
+    return Twimock::AuthHash.new unless validate_access_token_string(access_token_string)
+
+    if access_token = Twimock::AccessToken.find_by_string(access_token_string)
+      if user = Twimock::User.find_by_id(access_token.user_id)
+        hash = Twimock::AuthHash.new({
+          provider:    "twitter",
+          uid:         user.id,
+          info:        { name: user.name },
+          credentials: { token: access_token.string, expires_at: Time.now + 60.days },
+          extra:       { raw_info: { id: user.id, name: user.name } }
+        })
+      end
+    end
+    hash || Twimock::AuthHash.new
+  end
+
+  private
+
+  def validate_access_token_string(string)
+    string.kind_of?(String) && string.size > 0
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter '.bundle/'
+  add_filter '/spec/'
+end
+
+# spec/support 以下のヘルパーを読み込み
+Dir[File.expand_path('../support/', __FILE__) + '/**/*.rb'].each {|f| require f}
+
+require 'twimock'

data/spec/support/api_spec_helper.rb

@@ -0,0 +1,30 @@
+module APISpecHelper
+  shared_examples 'TestRackApplication 200 OK' do
+    it 'should return 200 OK' do
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to be_blank
+      expect(last_response.header).to be_blank
+    end
+  end
+
+  shared_examples 'API 401 UnAuthorized' do
+    it 'should return 401 Unauthorized' do
+      expect(last_response.status).to eq 401
+      expect(last_response.header).not_to be_blank
+      expect(last_response.header['Content-Length']).to eq last_response.body.bytesize.to_s
+      expect(last_response.header['Content-Type']).to eq "application/json; charset=utf-8"
+      expect(last_response.body).not_to be_blank
+      parsed_body = JSON.parse(last_response.body)
+      expect(parsed_body["error"]["code"]).to match /^Invalid.*/
+    end
+  end
+
+  shared_examples 'API 500 InternalServerError' do
+    it 'should return 500' do
+      expect(last_response.status).to eq 500
+      expect(last_response.header).not_to be_blank
+      expect(last_response.header['Content-Length']).to eq last_response.body.bytesize.to_s
+      expect(last_response.body).not_to be_blank
+    end
+  end
+end

data/spec/support/omniauth_twitter_helper.rb

@@ -0,0 +1,26 @@
+module OmniAuthTwitterHelper
+  def create_request_env(request_token, request_secret)
+    { 
+      'rack.input'   => StringIO.new(""),
+      'rack.session' => { "session_id" => "123456",
+                          "callback_path" => "/",
+                          "omniauth.params" => {},
+                          "omniauth.origin" => "http://example.com/authentication",
+                          "oauth" => { "twitter" => { "callback_confirmed" => true,
+                                                      "request_token"  => request_token,
+                                                      "request_secret" => request_secret } } },
+      'rack.url_scheme'   => "http",
+      "GATEWAY_INTERFACE" => "CGI/1.1",
+      "PATH_INFO"         => "/users/auth/twitter",
+      "QUERY_STRING"      => "",
+      "REMOTE_ADDR"       => "127.0.0.1",
+      "REMOTE_HOST"       => "localhost.localdomain",
+      "REQUEST_METHOD"    => "GET",
+      "REQUEST_URI"       => "http://example.com/users/auth/twitter",
+      "SERVER_NAME"       => "example.com",
+      "SERVER_PORT"       => "80",
+      "SERVER_PROTOCOL"   => "HTTP/1.1",
+      "HTTP_HOST"         => "example.com",
+    }
+  end
+end

data/spec/support/tables_helper.rb

@@ -0,0 +1,54 @@
+module TableHelper
+  def remove_dynamically_defined_all_method
+    klasses = [Twimock::Database::Table]
+    klasses.each do |klass|
+      remove_dynamically_defined_class_method(klass)
+      remove_dynamically_defined_instance_method(klass)
+    end
+  end
+
+  # テストで動的に定義したクラスメソッドを削除
+  def remove_dynamically_defined_class_method(klass)
+    klass.methods.each do |method_name|
+      if method_name.to_s =~ /^find_by_/ || method_name.to_s =~ /^find_all_by_/
+        klass.class_eval do
+          class_variable_set(:@@target_method_name, method_name)
+          class << self
+            remove_method class_variable_get(:@@target_method_name)
+          end
+          remove_class_variable(:@@target_method_name)
+        end
+      end
+    end
+  end
+
+  # テストで動的に定義したインスタンスメソッドを削除
+  def remove_dynamically_defined_instance_method(klass)
+    klass.column_names.each do |column_name|
+      getter = column_name
+      if klass.instance_methods.include?(getter)
+        klass.class_eval { remove_method getter }
+      end
+
+      setter = (column_name.to_s + "=").to_sym
+      if klass.instance_methods.include?(setter)
+        klass.class_eval { remove_method setter }
+      end
+    end
+  end
+
+  # Tableクラスでテストするために、一時的にDB Tableを作成する
+  def create_tables_table_for_test
+    db = Twimock::Database.new
+    db.connection.execute <<-SQL
+      CREATE TABLE TABLES (
+        id          INTEGER   PRIMARY KEY AUTOINCREMENT,
+        text        TEXT      NOT NULL,
+        active      BOOLEAN,
+        number      INTEGER   NOT NULL,
+        created_at  DATETIME  NOT NULL
+      );
+    SQL
+    db.disconnect!
+  end
+end

data/spec/support/test_application_helper.rb

@@ -0,0 +1,9 @@
+module TestApplicationHelper
+  extend self
+
+  class TestRackApplication
+    def call(env)
+      [ 200, {}, [] ]
+    end
+  end
+end

data/spec/twimock/access_token_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Twimock::AccessToken do
+  include TableHelper
+
+  let(:db_name)        { ".test" }
+  let(:table_name)     { :access_tokens }
+  let(:column_names)   { [ :id, :string, :secret, :application_id, :user_id, :created_at ] }
+
+  let(:id)             { 1 }
+  let(:string)         { "test_token" }
+  let(:secret)         { "test_token_secret" }
+  let(:application_id) { 1 }
+  let(:user_id)        { 1 }
+  let(:created_at)     { Time.now }
+  let(:options)        { { id:             id, 
+                           string:         string,
+                           secret:         secret,
+                           application_id: application_id,
+                           user_id:        user_id,
+                           created_at:     created_at } }
+
+  after { remove_dynamically_defined_all_method }
+
+  describe '::TABLE_NAME' do
+    subject { Twimock::AccessToken::TABLE_NAME }
+    it { is_expected.to eq table_name }
+  end
+
+  describe '::COLUMN_NAMES' do
+    subject { Twimock::AccessToken::COLUMN_NAMES }
+    it { is_expected.to eq column_names }
+  end
+
+  describe '#initialize' do
+    context 'without option' do
+      subject { Twimock::AccessToken.new }
+      it { is_expected.to be_kind_of Twimock::AccessToken }
+
+      describe '.id' do
+        subject { Twimock::AccessToken.new.id }
+        it { is_expected.to be_nil }
+      end
+
+      describe '.string' do
+        subject { Twimock::AccessToken.new.string }
+        it { is_expected.to be_kind_of String }
+
+        describe '.size' do
+          subject { Twimock::AccessToken.new.string.size }
+          it { is_expected.to eq 50 }
+        end
+      end
+
+      describe '.secret' do
+        subject { Twimock::AccessToken.new.secret }
+        it { is_expected.to be_kind_of String }
+
+        describe '.size' do
+          subject { Twimock::AccessToken.new.secret.size }
+          it { is_expected.to eq 45 }
+        end
+      end
+
+      describe '.user_id' do
+        subject { Twimock::AccessToken.new.user_id }
+        it { is_expected.to be_nil }
+      end
+
+      describe '.application_id' do
+        subject { Twimock::AccessToken.new.application_id }
+        it { is_expected.to be_nil }
+      end
+
+      describe '.created_at' do
+        subject { Twimock::AccessToken.new.created_at }
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context 'with id option but it is not integer' do
+      before { @opts = { id: "test_id" } }
+      subject { Twimock::AccessToken.new(@opts) }
+      it { is_expected.to be_kind_of Twimock::AccessToken }
+
+      describe '.id' do
+        subject { Twimock::AccessToken.new(@opts).id }
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context 'with user_id option but it is not integer' do
+      before { @opts = { user_id: "test_id" } }
+      subject { Twimock::AccessToken.new(@opts) }
+      it { is_expected.to be_kind_of Twimock::AccessToken }
+
+      describe '.user_id' do
+        subject { Twimock::AccessToken.new(@opts).user_id }
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context 'with application_id option but it is not integer' do
+      before { @opts = { application_id: "test_id" } }
+      subject { Twimock::AccessToken.new(@opts) }
+      it { is_expected.to be_kind_of Twimock::AccessToken }
+
+      describe '.application_id' do
+        subject { Twimock::AccessToken.new(@opts).application_id }
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context 'with all options' do
+      subject { Twimock::AccessToken.new(options) }
+      it { is_expected.to be_kind_of Twimock::AccessToken }
+
+      context 'then attributes' do
+        it 'should set specified value by option' do
+          column_names.each do |column_name|
+            value = Twimock::AccessToken.new(options).send(column_name)
+            expect(value).to eq options[column_name]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/twimock/api/account/verify_credentials_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'rack/test'
+
+describe Twimock::API::Account::VerifyCredentials do
+  include TestApplicationHelper
+  include Rack::Test::Methods
+
+  let(:method) { 'GET' }
+  let(:path)   { '/1.1/account/verify_credentials.json' }
+  let(:authorization_regexp) { Regexp.new('OAuth oauth_consumer_key=\"(.*)\", oauth_nonce=\"(.*)\", oauth_signature=\"(.*)\", oauth_signature_method=\"(.*)\", oauth_timestamp=\"(.*)\", oauth_token=\"(.*)\", oauth_version=\"(.*)\".*') }
+  
+  let(:oauth_consumer_key)     { Twimock::Application.new.api_key }
+  let(:oauth_nonce)            { "Tc400qacfXAoixQ5Tk9yeFjdBBrDb7U3Sdgs7WA8cM" }
+  let(:oauth_signature)        { "I7LRwjN%2FRvqp53kia2fGCg%2FrBHo%3D" }
+  let(:oauth_signature_method) { "HMAC-SHA1" }
+  let(:oauth_timestamp)        { "1422273906" }
+  let(:oauth_token)            { Twimock::AccessToken.string }
+  let(:oauth_version)          { "1.0" }
+  let(:authorization_header)   { [ "OAuth oauth_consumer_key=\"#{oauth_consumer_key}\", oauth_nonce=\"#{oauth_nonce}\", oauth_signature=\"#{oauth_signature}\", oauth_signature_method=\"#{oauth_signature_method}\", oauth_timestamp=\"#{oauth_timestamp}\", oauth_token=\"#{oauth_token}\", oauth_version=\"#{oauth_version}\"" ] }
+
+  let(:body) { "" }
+  let(:header) { {} }
+  let(:test_app) { TestApplicationHelper::TestRackApplication.new }
+  let(:app)      { Twimock::API::Account::VerifyCredentials.new(test_app) }
+
+  describe '::METHOD' do
+    subject { Twimock::API::Account::VerifyCredentials::METHOD }
+    it { is_expected.to eq method }
+  end
+
+  describe '::PATH' do
+    subject { Twimock::API::Account::VerifyCredentials::PATH }
+    it { is_expected.to eq path }
+  end
+
+  describe '::AUTHORIZATION_REGEXP' do
+    subject { Twimock::API::Account::VerifyCredentials::AUTHORIZATION_REGEXP }
+    it { is_expected.to eq authorization_regexp }
+  end
+
+  describe "GET '/1.1/account/verify_credentials.json'" do
+    context 'with authorization header' do
+      let(:db_name) { ".test" }
+      let(:database) { Twimock::Database.new }
+
+      before { stub_const("Twimock::Database::DEFAULT_DB_NAME", db_name) }
+      after  { database.drop }
+
+      context 'that is correct' do
+        let(:header) { { "authorization" => authorization_header } }
+        let(:oauth_consumer_key) { @application.api_key }
+        let(:oauth_token)        { @access_token.string }
+
+        before do 
+          @application = Twimock::Application.new
+          @application.save!
+          @user = Twimock::User.new
+          @user.save!
+          @access_token = @user.generate_access_token(@application.id)
+        end
+
+        it 'should return 200 OK' do
+          get path, body, header
+
+          expect(last_response.status).to eq 200
+          expect(last_response.header).not_to be_blank
+          expect(last_response.header['Content-Length']).to eq last_response.body.bytesize.to_s
+          expect(last_response.body).not_to be_blank
+
+          # bodyの検証
+          parsed_body = JSON.parse(last_response.body)
+          expect(parsed_body['id']).to eq @user.id
+          expect(parsed_body['id_str']).to eq @user.id.to_s
+          expect(parsed_body['name']).to eq @user.name
+          expect(parsed_body['created_at']).to eq @user.created_at.to_s
+        end
+      end
+
+      context 'that is incorrect format' do
+        let(:consumer_key) { "test_consumer_key" }
+        before { get path, body, header }
+        it_behaves_like 'API 401 UnAuthorized'
+      end
+
+      context 'but consumer_key is invalid' do
+        before { get path, body, header }
+        it_behaves_like 'API 401 UnAuthorized'
+      end
+    end
+
+    context 'without authorization header', assert: :UnauthorizedAccountVerifyCredentials do
+      let(:authorization_header) { nil }
+      before { get path, body, header }
+      it_behaves_like 'API 401 UnAuthorized'
+    end
+
+    context 'raise error that is not catched' do
+      let(:header) { { "authorization" => authorization_header } }
+      let(:oauth_consumer_key) { @application.api_key }
+      let(:oauth_token)        { @access_token.string }
+
+      before do 
+        @application = Twimock::Application.new
+        @application.save!
+        @user = Twimock::User.new
+        @user.save!
+        @access_token = @user.generate_access_token(@application.id)
+        allow(Twimock::User).to receive(:find_by_id) { raise }
+        get path, body, header
+      end
+
+      it_behaves_like 'API 500 InternalServerError'
+    end
+  end
+
+  describe "GET '/test'" do
+    before { get '/test' }
+    it_behaves_like 'TestRackApplication 200 OK'
+  end
+
+  describe "POST '/1.1/account/verify_credentials.json'" do
+    before { post '/1.1/account/verify_credentials.json' }
+    it_behaves_like 'TestRackApplication 200 OK'
+  end
+end

data/spec/twimock/api/application_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Twimock::API::Application do
+  before do
+    allow_any_instance_of(Excon::Connection).to receive(:request) do
+      options = { status: status, headers: headers, body: body }
+      response = Excon::Response.new(options)
+    end
+  end
+
+  let(:status)  { 200 }
+  let(:headers) { { "Content-Length" => 4, "Content-Type"=>"text/plain" } }
+  let(:body)    { "test_body" }
+
+  let(:env)     { { "rack.input"     => StringIO.new(body),
+                    "REQUEST_METHOD" => "GET",
+                    "SERVER_NAME"    => "api.twitter.com",
+                    "SERVER_PORT"    => "443",
+                    "QUERY_STRING"   => "",
+                    "PATH_INFO"      => "/",
+                    "HTTPS"          => "on" } }
+
+  describe 'call' do
+    subject { Twimock::API::Application.new.call(env) }
+    it { is_expected.to eq [ status, headers, [ body ] ] }
+  end
+end