voxcast_api 1.0.0 → 1.0.1

data/lib/voxcast_api/base.rb

@@ -1,11 +1,15 @@
+gem 'url_maker'
 require 'time'
 require 'set'
 require 'digest/md5'
 require 'forwardable'
 require 'hpricot'
+require 'active_support/core_ext/hash'
+require 'url_maker'
 
 class VoxcastApi::Base < VoxcastApi::Http
   extend Forwardable
+  include UrlMaker
 
   def_delegators :@entry, :device_id
   attr_accessor :key, :secret_key

data/lib/voxcast_api/http.rb

@@ -1,5 +1,4 @@
 class VoxcastApi::Http
-  include UrlMaker
   attr_accessor :url, :user, :password
 
   def initialize(entry = nil)

data/spec/lib/voxcast_api_spec.rb

@@ -0,0 +1,174 @@
+require 'cgi'
+require 'net/http'
+require 'digest/md5'
+require 'voxcast_api'
+
+describe VoxcastApi::Base do
+  class MockHTTP
+    attr_accessor :requests, :gets, :posts, :get_response, :auth,
+    :post_response, :request_response, :read_timeout, :use_ssl, :ssl_args
+
+    def initialize
+      @requests = []
+      @gets = []
+      @posts = []
+      @get_response = nil
+      @post_response = nil
+      @request_response = nil
+      @read_timeout = nil
+      @use_ssl = nil
+      @ssl_args = nil
+      # used to work with HTTPi expectations as well
+      @auth = MockAuth.new
+    end
+    
+    def start
+      yield self
+    end
+
+    def ssl_client_auth(ssl_args)
+      @ssl_args = ssl_args
+    end
+
+    def request(req)
+      @requests << req
+      @request_response
+    end
+
+    def get(uri)
+      @gets << uri
+      @get_response
+    end
+
+    def post(uri, data)
+      @posts << [uri, data]
+      @post_response
+    end
+  end
+
+  class MockAuth
+    attr_accessor :user, :password, :verify_mode, :ssl
+
+    def initialize(init_ssl = true)
+      @user = @password = @verify_mode = nil
+      @ssl = MockAuth.new(false) if init_ssl
+    end
+
+    def basic(user, pass)
+      @user = user
+      @password = pass
+    end
+  end
+
+  def mock_http(set = true)
+    http = MockHTTP.new
+    Net::HTTP.stub!(:new).and_return(http) if set
+    http
+  end
+
+  def setup_http(code = '200', body = '')
+    @mock_http = mock_http
+    @mock_resp = mock('response')
+    @mock_resp.stub!(:code).and_return code
+    @mock_resp.stub!(:body).and_return body
+    @mock_http.get_response = @mock_resp
+    @mock_http.post_response = @mock_resp
+    @mock_http.request_response = @mock_resp
+  end
+
+  before(:each) do
+    @mock_entry = mock("Voxcast", :purge_url => 'http://purge.com', :purge_user => 'user', 
+                             :purge_password => 'pass', :purge_key => 'key', :purge_secret_key => 'secret',
+                             :http_domain => 'domain', :logger => nil)
+    @api = VoxcastApi::Base.new(@mock_entry)
+    base_dir = File.expand_path('../../../xml', __FILE__)
+    @log_list = File.join(base_dir, 'log_list.xml')
+    @purge_ret = File.join(base_dir, 'purge.xml')
+  end
+
+  it "should check auth_key? properly" do
+    params = {}
+    @api.auth_key?(params).should == false
+    params = {'method' => 'something'}
+    @api.auth_key?(params).should == false
+    params = {'method' => 'voxel.hapi.authkeys.read'}
+    @api.auth_key?(params).should == true
+  end
+
+  it "should execute_method properly" do
+    params = {'a' => 'b'}
+    looked = 'found'
+    @api.should_receive(:execute).with(nil, params.merge('method' => looked))
+    @api.should_receive(:lookup_method).with(:purge_file).and_return looked
+    @api.execute_method(:purge_file, params)
+  end
+
+  it "should execute_method for auth_key" do
+    @api.should_receive(:execute).with('https://purge.com', {'method' => 'voxel.hapi.authkeys.read'})
+    @api.execute_method(:auth_key)
+  end
+
+  it "should generate api_sig properly" do
+    params = {'a' => 'b', 
+      'c' => 'd'
+    }
+    expected = Digest::MD5.hexdigest('secret keyabcd')
+    sig = @api.api_sig(params, 'secret key')
+    sig.should == expected
+  end
+
+  it "should generate api_sig if using sym" do
+    params = {:c => 'd', 
+      'a' => 'b'
+    }
+    expected = Digest::MD5.hexdigest('secret keyabcd')
+    sig = @api.api_sig(params, 'secret key')
+    sig.should == expected
+  end
+
+  it "should process_response properly" do
+    resp = mock('response')
+    body = File.read(@purge_ret)
+    resp.stub!(:code).and_return 200
+    resp.stub!(:body).and_return body
+    ret = @api.process_response(resp)
+    ret[:status].should == true
+    id = '048c7546-b4f8-42f4-89da-3544cbd13c4c'
+    ret[:detail]['transaction']['id'].should == id
+  end
+
+  it "should get_data properly" do
+    @api.should_receive(:timestamp).and_return 'timestamp'
+    @api.should_receive(:api_sig).and_return 'sig'
+    CGI.parse(@api.get_data).should == {'timestamp' => ['timestamp'], 'key' => ['key'], 'api_sig' => ['sig']}
+  end
+
+  it "should handle log_list which return error" do
+    @api.should_receive(:execute_method).with(:log_list, {:complex_parser => true}).and_return({:status => false})
+    @api.log_list.should == []
+  end
+
+  it "should handle log_list properly" do
+    setup_http
+    body = File.read(@log_list)
+    @mock_resp.stub!(:body).and_return body
+    ret = @api.log_list
+    # there should be 4 log files
+    ret.size.should == 4
+  end
+
+  it "should handle log_download properly" do
+    setup_http
+    @mock_resp.stub!(:body).and_return 'blah'
+    dst = File.join('/tmp', 'dst_file')
+    begin
+      @api.should_not_receive(:process_response)
+      @api.log_download('myfile', dst).should be_true
+      File.exists?(dst).should be_true
+      File.read(dst).should == 'blah'
+    ensure
+      File.delete(dst) if File.exists?(dst)
+    end
+  end
+  
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Bruce Wang
@@ -34,6 +34,7 @@ files:
 - lib/voxcast_api/base.rb
 - lib/voxcast_api/http.rb
 - lib/voxcast_api/purge.rb
+- spec/lib/voxcast_api_spec.rb
 has_rdoc: true
 homepage: http://rubygems.org/gems/voxcast_api
 licenses: []