backup-pcs 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 049ec16812b9a9610beaf7dcbb21fff5cfeb4072
+  data.tar.gz: 42ae0e0c689a2a90e70a64ebdad97b49181664b9
+SHA512:
+  metadata.gz: 48a5abf2774d5820571acf27583bf50fbeb9b897625ae363f5a366102b6fcbf143a1717f870843c4d62ec3111936d3bc2df50ac25da28fb7b2687d454eec1c8d
+  data.tar.gz: b592117bfd34d9cfeb38002898a84e9fcc99366b811b60f200daf8dc7d6993f66b1839b6f694a568234683a7ba9889da211b7048fb2768b3dd4a30c841a8a5f0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+bundler_args: --without development
+script: 'bundle exec rake spec'
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - rbx-2.1.1
+  - jruby-19mode
+  - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: rbx-2.1.1
+    - rvm: jruby-19mode
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+group :development do
+  gem 'guard-rspec'
+  gem 'terminal-notifier-guard' if /darwin/ =~ RUBY_PLATFORM
+end
+
+group :test, :development do
+  gem 'rake'
+  gem 'rspec'
+end
+
+gem 'rubysl', platforms: :rbx
+
+# Specify your gem's dependencies in backup-pcs.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, all_on_start: true, all_after_pass: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Lonre Wang
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# Baidu PCS Storage for Backup [![Build Status](https://travis-ci.org/lonre/backup-pcs.png?branch=master)](https://travis-ci.org/lonre/backup-pcs)
+
+`PCS(Personal Cloud Storage)`是百度推出的针对个人用户的云存储服务
+
+本 Gem 为 [Backup](https://github.com/meskyanichi/backup) Storage 插件，可以将数据备份到 `PCS`
+
+使用 `backup-pcs` 前必须到 [百度开发者中心](http://developer.baidu.com/console) 开启指定应用的 PCS API 权限，参考 [开通PCS API权限](http://developer.baidu.com/wiki/index.php?title=docs/pcs/guide/api_approve)，并获取所设置的文件目录
+
+## 安装
+
+```
+$ gem install backup-pcs
+```
+`backup-pcs` 当前支持 Ruby(MRI) 版本：1.9.3, 2.0.0
+
+## 用法
+
+此说明只提供了本 Gem 的配置使用方法，关于 Backup 的详细使用方法，请参考 [Backup GitHub Page](https://github.com/meskyanichi/backup)
+
+用你喜欢的文本编辑器，打开 Backup model 文件，如：`~/Backup/models/mysite.rb`
+
+### 引入依赖
+
+在头部添加依赖
+
+```ruby
+require 'backup/pcs'
+```
+
+### 配置
+
+在主体部分添加如下配置：
+
+```ruby
+store_with :PCS do |p|
+  p.client_id     = 'a_client_id'
+  p.client_secret = 'a_cliet_secret'
+  p.dir_name      = 'Backups'         # 开通 PCS API 权限时所设置的文件目录
+  p.path          = 'data'            # 保存路径，从 dir_name 算起
+  # p.keep          = 2
+  # p.max_retries   = 10              # 出错后重试次数，默认 10 次
+  # p.retry_waitsec = 30              # 出错后重试等待秒数，默认 30 秒
+end
+```
+
+### 注意
+
+在配置完成之后，您必须手动在系统中运行一次 `Backup`，根据终端的提示完成授权。在授权完毕之后，授权信息会被缓存，这样，当后续自动任务触发 `Backup` 时，会自动加载此缓存授权信息。
+
+## Copyright
+MIT License. Copyright (c) 2013 Lonre Wang.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

data/backup-pcs.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'backup/pcs/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "backup-pcs"
+  spec.version       = Backup::PCS::VERSION
+  spec.authors       = ["Lonre Wang"]
+  spec.email         = ["me@wanglong.me"]
+  spec.description   = %q{Backup Storage for supporting Baidu Personal Cloud Storage(PCS)}
+  spec.summary       = %q{Baidu PCS Storage for Backup}
+  spec.homepage      = "https://github.com/lonre/backup-pcs"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency     "baidu-sdk", "~> 0.0.1"
+  spec.add_runtime_dependency     "backup",    "~> 3.9.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+end

data/lib/backup/pcs/version.rb

@@ -0,0 +1,5 @@
+module Backup
+  module PCS
+    VERSION = "0.0.1"
+  end
+end

data/lib/backup/pcs.rb

@@ -0,0 +1,3 @@
+require "backup"
+
+Backup::Storage.autoload(:PCS, File.join(File.dirname(__FILE__), 'storage/pcs'))

data/lib/backup/storage/pcs.rb

@@ -0,0 +1,131 @@
+require 'base64'
+require 'json'
+require 'baidu/oauth'
+require 'baidu/pcs'
+
+module Backup
+  module Storage
+    class PCS < Base
+      class Error < Backup::Error; end
+
+      attr_accessor :client_id, :client_secret, :dir_name, :max_retries, :retry_waitsec
+
+      def initialize(model, storage_id=nil)
+        super
+
+        @path          ||= 'backups'
+        @max_retries   ||= 10
+        @retry_waitsec ||= 30
+      end
+
+      private
+
+      def transfer!
+        package.filenames.each do |filename|
+          src  = File.join(Config.tmp_path, filename)
+          dest = File.join(remote_path, filename)
+          Logger.info "Storing '#{ dest }'..."
+          auto_refresh_token do
+            File.open(src, 'r') do |file|
+              client.upload file, path: dest, block_upload: true,
+                                              retry_times: @max_retries,
+                                              retry_waitsec: @retry_waitsec
+            end
+          end
+        end
+      rescue => err
+        raise Error.wrap(err, 'Upload Failed!')
+      end
+
+      def remove!(package)
+        Logger.info "Removing backup package dated #{ package.time }..."
+
+        auto_refresh_token do
+          client.delete(remote_path_for(package))
+        end
+      end
+
+      # create or get Baidu PCS client
+      def client
+        return @client if @client
+
+        unless session = cached_session
+          Logger.info "Creating a new Baidu session!"
+          session = create_session!
+        end
+
+        @client = Baidu::PCS::Client.new(session, dir_name)
+      rescue => err
+        raise Error.wrap(err, 'Authorization Failed.')
+      end
+
+      # cache Baidu::Session
+      def cached_session
+        session = false
+        if File.exist?(cached_file)
+          begin
+            content = Base64.decode64(File.read(cached_file))
+            session = Marshal.load(content)
+            Logger.info "Baidu session data loaded from cache!"
+          rescue => err
+            Logger.warn Error.wrap(err, "Cached file: #{cached_file} might be corrupt.")
+          end
+        end
+        session
+      end
+
+      def auto_refresh_token
+        tries = 0
+        begin
+          yield
+        rescue Baidu::Errors::AuthError => e
+          raise Error, 'Too many auth errors' if (tries += 1) > 5
+          Logger.info "Refreshing Baidu session..."
+          session = oauth_client.refresh(cached_session.refresh_token)
+          raise Error.wrap(e, 'Authorization Failed!') unless session
+          write_cache! session
+          @client = nil
+          retry
+        end
+      end
+
+      def cached_file
+        File.join(Config.cache_path, "pcs_#{storage_id}_#{client_id}")
+      end
+
+      def write_cache!(session)
+        FileUtils.mkdir_p(Config.cache_path)
+        File.open(cached_file, "w") do |cache_file|
+          cache_file.write(Base64.encode64(Marshal.dump(session)))
+        end
+      end
+
+      def oauth_client
+        Baidu::OAuth::Client.new(client_id, client_secret)
+      end
+
+      def create_session!
+        require 'timeout'
+
+        device_flow = oauth_client.device_flow
+        rest = device_flow.user_and_device_code('netdisk')
+
+        STDOUT.puts "1. Visit verification url: #{rest[:verification_url]}"
+        STDOUT.puts "2. Type user code below in the form"
+        STDOUT.puts "\t #{rest[:user_code]}"
+        STDOUT.puts "3. Hit 'Enter/Return' once you're authorized."
+
+        Timeout::timeout(300) { STDIN.gets }
+
+        session = device_flow.get_token(rest[:device_code])
+
+        write_cache!(session)
+        STDOUT.puts "Baidu session cached: #{cached_file}"
+
+        session
+      rescue => err
+        raise Error.wrap(err, 'Could not create a new session!')
+      end
+    end
+  end
+end

data/spec/pcs_spec.rb

@@ -0,0 +1,412 @@
+# encoding: UTF-8
+
+require 'backup/pcs'
+
+module Backup
+  describe Storage::PCS do
+    let(:model)   { Model.new(:test_trigger, 'test label') }
+    let(:storage) { Storage::PCS.new(model) }
+
+    describe '#initialize' do
+      it 'is a Storage::Base' do
+        expect(storage).to be_a(Storage::Base)
+      end
+
+      it 'has default config' do
+        expect(storage.storage_id   ).to be_nil
+        expect(storage.keep         ).to be_nil
+        expect(storage.client_id    ).to be_nil
+        expect(storage.client_secret).to be_nil
+        expect(storage.dir_name     ).to be_nil
+        expect(storage.path         ).to eq 'backups'
+        expect(storage.max_retries  ).to be 10
+        expect(storage.retry_waitsec).to be 30
+      end
+
+      it 'inits with config' do
+        storage = Storage::PCS.new(model, 'sid') do |c|
+          c.keep          = 1
+          c.client_id     = 'ci'
+          c.client_secret = 'cs'
+          c.dir_name      = 'dn'
+          c.path          = 'myback'
+          c.max_retries   = 2
+          c.retry_waitsec = 3
+        end
+
+        expect(storage.storage_id   ).to eq('sid')
+        expect(storage.keep         ).to eq(1)
+        expect(storage.client_id    ).to eq('ci')
+        expect(storage.client_secret).to eq('cs')
+        expect(storage.dir_name     ).to eq('dn')
+        expect(storage.path         ).to eq 'myback'
+        expect(storage.max_retries  ).to be(2)
+        expect(storage.retry_waitsec).to be(3)
+      end
+    end
+
+    describe '#transfer!' do
+      let(:timestamp)   { Time.now.strftime("%Y.%m.%d.%H.%M.%S") }
+      let(:remote_path) { File.join('myback/test_trigger', timestamp) }
+      let(:package) { double }
+      let(:file)    { double }
+      let(:client)  { double }
+      let(:cached_session) { double }
+      let(:storage) {
+        Storage::PCS.new(model, 'sid') do |c|
+          c.keep          = 1
+          c.client_id     = 'ci'
+          c.client_secret = 'cs'
+          c.dir_name      = 'dn'
+          c.path          = 'myback'
+          c.max_retries   = 2
+          c.retry_waitsec = 3
+        end
+      }
+
+      before do
+        allow(storage).to receive(:package).and_return(package)
+        allow(package).to receive(:trigger).and_return('test_trigger')
+        allow(package).to receive(:time).and_return(timestamp)
+        allow(file).to    receive(:size).and_return(68*1024*1024)
+        allow(storage).to receive(:client).and_return(client)
+        allow(storage).to receive(:cached_session).and_return(cached_session)
+      end
+
+      it 'transfers files' do
+        allow(client).to  receive(:upload)
+        allow(package).to receive(:filenames).
+          and_return(['test_trigger.tar_aa', 'test_trigger.tar_ab'])
+        src  = File.join(Config.tmp_path, 'test_trigger.tar_aa')
+        dest = File.join(remote_path, 'test_trigger.tar_aa')
+        expect(File).to   receive(:open).with(src, 'r').and_yield(file)
+        expect(client).to receive(:upload).with(file, path: dest, block_upload: true,
+                                                                   retry_times: 2,
+                                                                   retry_waitsec: 3)
+
+        src  = File.join(Config.tmp_path, 'test_trigger.tar_ab')
+        dest = File.join(remote_path, 'test_trigger.tar_ab')
+        expect(File).to    receive(:open).with(src, 'r').and_yield(file)
+        expect(client).to  receive(:upload).with(file, path: dest, block_upload: true,
+                                                                   retry_times: 2,
+                                                                   retry_waitsec: 3)
+        expect(storage).to receive(:auto_refresh_token).and_yield.twice
+        storage.send(:transfer!)
+      end
+
+      describe 'when access token expired' do
+        let(:oauth_client) { double }
+        let(:session) { double }
+
+        before do
+          allow(package).to  receive(:filenames).and_return(['test_trigger.tar_aa'])
+          allow(client).to   receive(:upload).and_raise(Baidu::Errors::AuthError, 'expired')
+          allow(storage).to  receive(:write_cache!).with(session) do
+            allow(client).to receive(:upload).and_return(nil)  # do not raise like before
+          end
+          allow(storage).to        receive(:oauth_client).and_return(oauth_client)
+          allow(cached_session).to receive(:refresh_token)
+        end
+
+        it 'refreshes access token automatically with valid refresh token' do
+          allow(oauth_client).to receive(:refresh).and_return(session)
+
+          src  = File.join(Config.tmp_path, 'test_trigger.tar_aa')
+          dest = File.join(remote_path, 'test_trigger.tar_aa')
+          expect(Logger).to receive(:info).with("Storing '#{dest}'...")
+          expect(File).to   receive(:open).with(src, 'r').and_yield(file).twice
+          expect(client).to receive(:upload).with(file, path: dest, block_upload: true,
+                                                                   retry_times: 2,
+                                                                   retry_waitsec: 3).twice
+          expect(Logger).to receive(:info).with('Refreshing Baidu session...')
+          storage.send(:transfer!)
+        end
+
+        it 'refreshes access token automatically with invalid refresh token' do
+          allow(cached_session).to receive(:refresh_token).and_return(nil)
+          allow(oauth_client).to   receive(:refresh).and_return(nil)
+
+          src  = File.join(Config.tmp_path, 'test_trigger.tar_aa')
+          dest = File.join(remote_path, 'test_trigger.tar_aa')
+          expect(Logger).to       receive(:info).with("Storing '#{dest}'...")
+          expect(File).to         receive(:open).with(src, 'r').and_yield(file).once
+          expect(Logger).to       receive(:info).with('Refreshing Baidu session...')
+          expect(oauth_client).to receive(:refresh)
+          expect(Kernel).to       receive(:raise)
+          expect(storage).to      receive(:write_cache!).never
+          expect {
+            storage.send(:transfer!)
+          }.to raise_error(Storage::PCS::Error)
+        end
+      end
+    end
+
+    describe '#remove!' do
+      let(:timestamp)   { Time.now.strftime("%Y.%m.%d.%H.%M.%S") }
+      let(:remote_path) { File.join('myback/test_trigger', timestamp) }
+      let(:package) { double }
+      let(:client)  { double }
+      let(:storage) {
+        Storage::PCS.new(model, 'sid') do |c|
+          c.keep          = 1
+          c.client_id     = 'ci'
+          c.client_secret = 'cs'
+          c.dir_name      = 'dn'
+          c.path          = 'myback'
+          c.max_retries   = 2
+          c.retry_waitsec = 3
+        end
+      }
+
+      before do
+        allow(storage).to receive(:package).and_return(package)
+        allow(package).to receive(:trigger).and_return('test_trigger')
+        allow(package).to receive(:time).and_return(timestamp)
+        allow(storage).to receive(:client).and_return(client)
+      end
+
+      it 'removes package' do
+        expect(Logger).to receive(:info).with("Removing backup package dated #{ timestamp }...")
+        expect(client).to receive(:delete).with(remote_path)
+
+        storage.send(:remove!, package)
+      end
+    end
+
+    describe '#client' do
+      let(:storage) {
+        Storage::PCS.new(model, 'sid') do |c|
+          c.keep          = 1
+          c.client_id     = 'ci'
+          c.client_secret = 'cs'
+          c.dir_name      = 'dn'
+          c.path          = 'myback'
+          c.max_retries   = 2
+          c.retry_waitsec = 3
+        end
+      }
+
+      it 'creates new session' do
+        session = double
+        client  = double
+        allow(storage).to receive(:cached_session).and_return(nil)
+        allow(storage).to receive(:create_session!).and_return(session)
+        allow(Baidu::PCS::Client).to receive(:new).with(session, 'dn').and_return(client)
+
+        expect(Logger).to  receive(:info).with('Creating a new Baidu session!')
+        expect(storage).to receive(:create_session!).once.and_return(session)
+
+        storage.send(:client)
+        expect(storage.instance_variable_get(:@client)).to eq(client)
+      end
+
+      it 'uses cached session' do
+        session = double
+        client  = double
+        allow(storage).to receive(:cached_session).and_return(session)
+        allow(Baidu::PCS::Client).to receive(:new).with(session, 'dn').and_return(client)
+
+        expect(storage).to receive(:create_session!).never
+
+        storage.send(:client)
+        expect(storage.instance_variable_get(:@client)).to eq(client)
+      end
+    end
+
+    describe '#cached_session' do
+      let(:storage) {
+        Storage::PCS.new(model, 'sid') do |c|
+          c.keep          = 1
+          c.client_id     = 'ci'
+          c.client_secret = 'cs'
+          c.dir_name      = 'dn'
+          c.path          = 'myback'
+          c.max_retries   = 2
+          c.retry_waitsec = 3
+        end
+      }
+
+      it 'has no cached file' do
+        expect(File).to receive(:exist?).and_return(false)
+        expect(storage.send(:cached_session)).to eq(false)
+      end
+
+      it 'loads cached session' do
+        session = double
+        content = double
+        base64_c = double
+        cached_file = storage.send(:cached_file)
+        expect(File).to    receive(:exist?).with(cached_file).and_return(true)
+        expect(File).to    receive(:read).with(cached_file).and_return(content)
+        expect(Base64).to  receive(:decode64).with(content).and_return(base64_c)
+        expect(Marshal).to receive(:load).with(base64_c).and_return(session)
+        expect(Logger).to  receive(:info).with('Baidu session data loaded from cache!')
+
+        expect(storage.send(:cached_session)).to eq(session)
+      end
+
+      it 'loads cached session failed' do
+        expect(File).to    receive(:exist?).and_return(true)
+        expect(File).to    receive(:read).and_raise('error.')
+        expect(Logger).to  receive(:warn)
+        expect(storage.send(:cached_session)).to eq(false)
+      end
+    end
+
+    describe '#auto_refresh_token' do
+      let(:session) { double }
+      let(:oauth_client) { double }
+      let(:cached_session) { double }
+      let(:storage) {
+        Storage::PCS.new(model, 'sid') do |c|
+          c.keep          = 1
+          c.client_id     = 'ci'
+          c.client_secret = 'cs'
+          c.dir_name      = 'dn'
+          c.path          = 'myback'
+          c.max_retries   = 2
+          c.retry_waitsec = 3
+        end
+      }
+
+      before do
+        allow(storage).to receive(:oauth_client).and_return(oauth_client)
+        allow(storage).to receive(:cached_session).and_return(cached_session)
+        allow(cached_session).to receive(:refresh_token)
+      end
+
+      it 'does not raise autu error' do
+        expect(Logger).to       receive(:info).with('Refreshing Baidu session...').never
+        expect(oauth_client).to receive(:refresh).never
+        expect(storage).to      receive(:write_cache!).never
+
+        storage.send(:auto_refresh_token) { }
+      end
+
+      it 'raises auth error with valid refresh token' do
+        work_p = proc { raise Baidu::Errors::AuthError, 'expired' }
+        allow(oauth_client).to receive(:refresh).and_return(session)
+        allow(storage).to receive(:write_cache!) do
+          work_p = proc { }
+        end
+
+        expect(Logger).to       receive(:info).with('Refreshing Baidu session...')
+        expect(oauth_client).to receive(:refresh)
+        expect(storage).to      receive(:write_cache!).with(session)
+
+        storage.send(:auto_refresh_token) { work_p.call }
+      end
+
+      it 'raises auth error with invalid refresh token' do
+        work_p = proc { raise Baidu::Errors::AuthError, 'expired' }
+        allow(oauth_client).to receive(:refresh).and_return(nil)
+        allow(storage).to receive(:write_cache!) do
+          work_p = proc { }
+        end
+
+        expect(Logger).to       receive(:info).with('Refreshing Baidu session...')
+        expect(oauth_client).to receive(:refresh)
+        expect(storage).to      receive(:write_cache!).never
+
+        expect {
+          storage.send(:auto_refresh_token) { work_p.call }
+        }.to raise_error(Storage::PCS::Error)
+      end
+
+      it 'raises when there are too many auth errors' do
+        work_p = proc { raise Baidu::Errors::AuthError, 'expired' }
+        allow(oauth_client).to receive(:refresh).and_return(session)
+        expect {
+          storage.send(:auto_refresh_token) { work_p.call }
+        }.to raise_error(Storage::PCS::Error, 'Storage::PCS::Error: Too many auth errors')
+      end
+    end
+
+    describe '#cached_file' do
+      it 'has right cached file path' do
+        path1 = Storage::PCS.new(model, 'sid') do |c|
+          c.client_id     = 'ci'
+        end.send(:cached_file)
+        expect(path1).to eq(Config.cache_path + '/pcs_sid_ci')
+
+        path2 = Storage::PCS.new(model) do |c|
+          c.client_id     = 'ci2'
+        end.send(:cached_file)
+        expect(path2).to eq(Config.cache_path + '/pcs__ci2')
+      end
+    end
+
+    describe '#write_cache!' do
+      let(:cached_file) { double }
+      let(:session) { double }
+
+      before do
+        storage.client_id = 'ci'
+        allow(FileUtils).to receive(:mkdir_p)
+        allow(storage).to receive(:cached_file).and_return(cached_file)
+      end
+
+      it 'writes cached file' do
+        expect(FileUtils).to receive(:mkdir_p).with(Config.cache_path)
+        expect(File).to receive(:open).with(cached_file, 'w').and_yield(cached_file)
+        data = Base64.encode64(Marshal.dump(session))
+        expect(cached_file).to receive(:write).with(data)
+
+        storage.send(:write_cache!, session)
+      end
+    end
+
+    describe '#oauth' do
+      before do
+        storage.client_id = 'ci'
+        storage.client_secret = 'cs'
+      end
+
+      it 'creates oauth client' do
+        oclient = double
+        expect(Baidu::OAuth::Client).to receive(:new).with('ci', 'cs').and_return(oclient)
+        expect(storage.send(:oauth_client)).to eq(oclient)
+      end
+    end
+
+    describe '#create_session!' do
+      let(:rest) { Hash.new }
+      before do
+        storage.client_id = 'ci'
+        storage.client_secret = 'cs'
+      end
+
+      it 'is authorized successfully' do
+        device_flow = double
+        oauth_client = double
+        session = double
+        expect(storage).to receive(:oauth_client).and_return(oauth_client)
+        expect(oauth_client).to receive(:device_flow).and_return(device_flow)
+        expect(device_flow).to receive(:user_and_device_code).with('netdisk').and_return(rest)
+
+        rest[:verification_url] = 'https://example.com/verification_url'
+        rest[:user_code]        = 'xxxyyy'
+        rest[:device_code]      = 'zzzzzz'
+
+        expect(STDOUT).to receive(:puts).with('1. Visit verification url: https://example.com/verification_url')
+        expect(STDOUT).to receive(:puts).with('2. Type user code below in the form')
+        expect(STDOUT).to receive(:puts).with("\t xxxyyy")
+        expect(STDOUT).to receive(:puts).with("3. Hit 'Enter/Return' once you're authorized.")
+        expect(STDIN).to  receive(:gets)
+        expect(STDOUT).to receive(:puts).with('Baidu session cached: ' + storage.send(:cached_file))
+
+        expect(device_flow).to receive(:get_token).with(rest[:device_code]).and_return(session)
+        expect(storage).to     receive(:write_cache!).with(session)
+
+        expect(storage.send(:create_session!)).to eq(session)
+      end
+
+      it 'is not authorized' do
+        allow(storage).to receive(:oauth_client).and_raise('any error')
+        expect {
+          storage.send(:create_session!)
+        }.to raise_error(Storage::PCS::Error)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: backup-pcs
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Lonre Wang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: baidu-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: backup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Backup Storage for supporting Baidu Personal Cloud Storage(PCS)
+email:
+- me@wanglong.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- backup-pcs.gemspec
+- lib/backup/pcs.rb
+- lib/backup/pcs/version.rb
+- lib/backup/storage/pcs.rb
+- spec/pcs_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/lonre/backup-pcs
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Baidu PCS Storage for Backup
+test_files:
+- spec/pcs_spec.rb
+- spec/spec_helper.rb
+has_rdoc: