cloudprint 0.1.3 → 0.2.0

data/lib/cloudprint/printer.rb

@@ -1,37 +1,33 @@
 module CloudPrint
   class Printer
-    attr_reader :id, :status, :name, :tags, :display_name
+    CONNECTION_STATUSES = %w{ONLINE UNKNOWN OFFLINE DORMANT}
+    CONFIG_OPTS = [:id, :status, :name, :tags, :display_name, :client, :connection_status, :description]
+    
+    attr_reader *CONFIG_OPTS
+    
     def initialize(options = {})
+      @client = options[:client]
       @id = options[:id]
       @status = options[:status]
       @name = options[:name]
       @display_name = options[:display_name]
       @tags = options[:tags] || {}
+      @connection_status = options[:connection_status] || 'UNKNOWN'
+      @description = options[:description]
     end
 
     def print(options)
       method = options[:content].is_a?(IO) ? :multipart_post : :post
-      response = CloudPrint.connection.send(method, '/submit', :printerid => self.id, :title => options[:title], :content => options[:content], :contentType => options[:content_type]) || {}
+      response = client.connection.send(method, '/submit', :printerid => self.id, :title => options[:title], :content => options[:content], :contentType => options[:content_type]) || {}
       return nil if response.nil? || response["job"].nil?
-      CloudPrint::PrintJob.new(:id => response["job"]["id"], :status => response["job"]["status"], :error_code => response["job"]["errorCode"])
+      client.print_jobs.new_from_response response["job"]
     end
 
-    class << self
-      def find(printer_id)
-        response = CloudPrint.connection.get('/printer', :printerid => printer_id)
-        first_printer_hash = response['printers'].first
-        new_from_hash(first_printer_hash)
-      end
-
-      def all
-        response = CloudPrint.connection.get('/search')
-        response['printers'].map { |p| new_from_hash(p) }
-      end
-
-      private
-
-      def new_from_hash(hash)
-        Printer.new(:id => hash['id'], :status => hash['status'], :name => hash['name'], :display_name => hash['displayName'], :tags => hash['tags'])
+    def method_missing(meth, *args, &block)
+      if CONNECTION_STATUSES.map{ |s| s.downcase + '?' }.include?(meth.to_s)
+        connection_status.downcase == meth.to_s.chop
+      else
+        super
       end
     end
   end

data/lib/cloudprint/printer_collection.rb

@@ -0,0 +1,52 @@
+module CloudPrint
+  class PrinterCollection
+
+    attr_reader :client
+    
+    def initialize client
+      @client = client
+    end
+    
+    def find(printer_id)
+      response = client.connection.get('/printer', :printerid => printer_id, :printer_connection_status => true)
+      first_printer_hash = response['printers'].first
+      new_printer_from_hash(first_printer_hash)
+    end
+
+    def all
+      search_all
+    end
+
+    def search(query = nil, conditions = {})
+      conditions[:q] = query unless query.nil?
+
+      response = client.connection.get('/search', conditions)
+      response['printers'].map { |p| new_printer_from_hash(p) }
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth =~ /^search_(#{Printer::CONNECTION_STATUSES.map(&:downcase).join('|')}|all)$/
+        search args[0], connection_status: $1.upcase
+      else
+        super
+      end
+    end
+
+    def new opts
+      Printer.new(opts.merge(client: client))
+    end
+
+    def new_printer_from_hash(hash)
+      Printer.new(
+        client: client,
+        id: hash['id'],
+        status: hash['status'],
+        name: hash['name'],
+        display_name: hash['displayName'],
+        tags: hash['tags'],
+        connection_status: hash['connectionStatus'],
+        description: hash['description']
+        )
+    end
+  end
+end

data/lib/cloudprint/version.rb

@@ -1,3 +1,3 @@
 module Cloudprint
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/test/cloudprint_test.rb

@@ -3,6 +3,7 @@ require 'helper'
 class CloudPrintTest < Test::Unit::TestCase
   def setup
     stub_access_token
+    @client = new_client
   end
 
   should "have CloudPrint" do
@@ -10,113 +11,108 @@ class CloudPrintTest < Test::Unit::TestCase
   end
 
   should "be able to set up CloudPrint" do
-    assert CloudPrint.respond_to?(:setup)
-  end
+    assert_nothing_raised do
+      CloudPrint::Client.new
+    end
+   end
 
   should "stores a client id, client secret, callback URL and refresh token" do
-    CloudPrint.setup(:refresh_token => 'refresh_token', :client_id => 'client_id', :client_secret => 'client_secret', :callback_url => 'callback_url')
-    assert_equal 'client_id', CloudPrint.client_id
-    assert_equal 'client_secret', CloudPrint.client_secret
-    assert_equal 'refresh_token', CloudPrint.refresh_token
-    assert_equal 'callback_url', CloudPrint.callback_url
+    client = CloudPrint::Client.new(:refresh_token => 'refresh_token', :client_id => 'client_id', :client_secret => 'client_secret', :callback_url => 'callback_url')
+    assert_equal 'client_id', client.client_id
+    assert_equal 'client_secret', client.client_secret
+    assert_equal 'refresh_token', client.refresh_token
+    assert_equal 'callback_url', client.callback_url
   end
 
   should "check if the access token is still valid" do
-    CloudPrint.expects(:access_token_valid?).returns(true)
-    CloudPrint.stubs(:get_existing_access_token).returns(mock_access_token)
-    CloudPrint.access_token
+    @client.expects(:access_token_valid?).returns(true)
+    @client.stubs(:renew_access_token!).returns(mock_access_token)
+    @client.access_token
   end
 
   should "get the existing access token use it if it's still valid" do
     token = mock_access_token
     token.expects(:token)
 
-    CloudPrint.stubs(:access_token_valid?).returns(true)
-    CloudPrint.expects(:get_existing_access_token).once.returns(token)
-    CloudPrint.expects(:get_new_access_token).never
-    CloudPrint.access_token
+    @client.stubs(:access_token_valid?).returns(true)
+    @client.instance_variable_set :@access_token, token
+    @client.expects(:renew_access_token!).never
+    @client.access_token
   end
 
   should "get the existing access token get a new one if it's no longer valid" do
-    CloudPrint.stubs(:access_token_valid?).returns(false)
-    CloudPrint.expects(:get_new_access_token).returns(mock_access_token)
-    CloudPrint.access_token
-  end
-
-  should "not set a nil access token" do
-    CloudPrint.expects(:get_existing_access_token).returns(nil)
-    CloudPrint.expects(:get_new_access_token).returns(mock_access_token)
-    CloudPrint.access_token
+    @client.stubs(:access_token_valid?).returns(false)
+    @client.expects(:renew_access_token!).returns(mock_access_token)
+    @client.access_token
   end
 
   should "not have a nil access token" do
-    CloudPrint.expects(:get_existing_access_token).at_least_once.returns(mock_access_token(nil))
-    CloudPrint.expects(:get_new_access_token).returns(mock_access_token)
-    CloudPrint.access_token
+    @client.instance_variable_set :@access_token, nil
+    @client.expects(:renew_access_token!).returns(mock_access_token)
+    @client.access_token
   end
 
   should "not allow a blank string for an access token" do
-    CloudPrint.expects(:get_existing_access_token).at_least_once.returns(mock_access_token(' '))
-    CloudPrint.expects(:get_new_access_token).returns(mock_access_token)
-    CloudPrint.access_token
+    @client.instance_variable_set :@access_token, ' '
+    @client.expects(:renew_access_token!).returns(mock_access_token)
+    @client.access_token
   end
 
   should "have a string as an access token" do
-    CloudPrint.stubs(:access_token_valid?).returns(true)
-    CloudPrint.expects(:get_new_access_token).never
-    CloudPrint.expects(:get_existing_access_token).at_least_once.returns(mock_access_token)
-    assert_equal("token", CloudPrint.access_token)
+    @client.stubs(:access_token_valid?).returns(true)
+    @client.expects(:renew_access_token!).never
+    @client.instance_variable_set :@access_token, mock_access_token
+    assert_equal("token", @client.access_token)
   end
 
   should "initialize an OAuth2 client when getting a new access token" do
-    CloudPrint.stubs(:access_token_valid?).returns(false)
-    CloudPrint.expects(:oauth_client)
-    CloudPrint.access_token
+    @client.stubs(:access_token_valid?).returns(false)
+    @client.expects(:oauth_client)
+    @client.access_token
   end
 
   should "set up an oauth client" do
-    CloudPrint.setup(:client_id => 'client_id', :client_secret => 'client_secret', :callback_url => "http://test.com/callback")
-    CloudPrint.stubs(:access_token_valid?).returns(false)
+    client = CloudPrint::Client.new(:client_id => 'client_id', :client_secret => 'client_secret', :callback_url => "http://test.com/callback")
+    client.stubs(:access_token_valid?).returns(false)
     OAuth2::Client.expects(:new).with('client_id', 'client_secret',
                                       :authorize_url => "/o/oauth2/auth",
                                       :token_url => "/o/oauth2/token",
                                       :access_token_url => "/o/oauth2/token",
                                       :site => 'https://accounts.google.com/')
 
-    CloudPrint.access_token
+    client.access_token
   end
 
   should "initialize an access token when getting a new access token" do
-    CloudPrint.setup(:refresh_token => "refresh_token")
-    CloudPrint.stubs(:access_token_valid?).returns(false)
+    client = CloudPrint::Client.new(:refresh_token => "refresh_token")
+    client.stubs(:access_token_valid?).returns(false)
 
-    CloudPrint.expects(:new_oauth2_access_token).returns(mock_access_token)
-    CloudPrint.access_token
+    client.expects(:renew_access_token!).returns(mock_access_token)
+    client.access_token
   end
 
   should "get an auth token from oauth2" do
     token = mock_access_token
-    CloudPrint.setup(:refresh_token => "refresh_token")
-    CloudPrint.stubs(:access_token_valid?).returns(false)
+    @client.stubs(:access_token_valid?).returns(false)
     stub_oauth_client
 
     OAuth2::AccessToken.expects(:new).with(mock_oauth_client, "", :refresh_token => "refresh_token").returns(token)
     token.expects(:refresh!).returns(mock_access_token)
-    CloudPrint.access_token
+    @client.access_token
   end
 
   should "expire if the access token is invalid" do
     token = mock_access_token
     token.stubs(:expired?).returns(true)
-    CloudPrint.stubs(:get_existing_access_token).returns()
+    @client.instance_variable_set :@access_token, token
     stub_oauth_client
 
-    CloudPrint.expects(:get_new_access_token).returns(token)
-    CloudPrint.access_token
+    @client.expects(:renew_access_token!).returns(token)
+    @client.access_token
   end
 
   should "get a new access token when setting a new refresh token" do
-    CloudPrint.expects(:get_new_access_token)
-    CloudPrint.refresh_token = 'new_token'
+    @client.expects(:renew_access_token!)
+    @client.refresh_token = 'new_token'
   end
 end

data/test/connection_test.rb

@@ -2,7 +2,8 @@ require "helper"
 
 class ConnectionTest < Test::Unit::TestCase
   def setup
-    @connection = CloudPrint::Connection.new
+    stub_access_token
+    @connection = new_client.connection
   end
 
   should "get using a connection" do
@@ -66,7 +67,6 @@ class ConnectionTest < Test::Unit::TestCase
     stub
     @connection.stubs(:build_http_connection).returns(mock_http)
 
-    CloudPrint.expects(:access_token).returns('token')
     @connection.get('/submit')
   end
 

data/test/helper.rb

@@ -4,6 +4,11 @@ require 'shoulda/context'
 require 'mocha'
 
 class Test::Unit::TestCase
+
+  def new_client
+    CloudPrint::Client.new(refresh_token: "refresh_token")
+  end
+  
   def any_connection
     CloudPrint::Connection.any_instance
   end
@@ -26,7 +31,6 @@ class Test::Unit::TestCase
 
   def stub_http
     mock = mock_http()
-
     Net::HTTP.stubs(:new).returns(mock)
   end
 
@@ -45,7 +49,7 @@ class Test::Unit::TestCase
   end
 
   def stub_oauth_client
-    CloudPrint.stubs(:oauth_client).returns(mock_oauth_client)
+    CloudPrint::Client.any_instance.stubs(:oauth_client).returns(mock_oauth_client)
   end
 
   def fake_connection
@@ -53,7 +57,7 @@ class Test::Unit::TestCase
   end
 
   def stub_connection
-    CloudPrint.stubs(:connection).returns(fake_connection)
+    CloudPrint::Client.any_instance.stubs(:connection).returns(fake_connection)
     @connection.stub_everything
   end
 

data/test/print_job_test.rb

@@ -3,32 +3,41 @@ require 'helper'
 class PrintJobTest < Test::Unit::TestCase
   def setup
     # TODO: Is it necessary to pass a fake token to #setup?
-    CloudPrint.setup(:refresh_token => 'refresh_token')
+    @client = new_client
     stub_connection
   end
 
   should "find a job" do
     fake_connection.stubs(:get).with('/jobs').returns(jobs_response)
-    assert CloudPrint::PrintJob.find('job_id').is_a?(CloudPrint::PrintJob)
+    assert @client.print_jobs.find('job_id').is_a?(CloudPrint::PrintJob)
   end
 
   should 'perform a remote request when finding a job' do
     fake_connection.expects(:get).with('/jobs').returns({})
 
-    CloudPrint::PrintJob.find('job_id')
+    @client.print_jobs.find('job_id')
   end
 
   should 'gets the job details' do
     fake_connection.stubs(:get).with('/jobs').returns(jobs_response)
-    job = CloudPrint::PrintJob.find('job_id')
+    job = @client.print_jobs.find('job_id')
 
     assert_equal 'job_id', job.id
     assert_equal 'status', job.status
     assert_equal 'Error', job.error_code
+    assert_equal 'printer_id', job.printer_id
+    assert_equal 'Job Title', job.title
+    assert_equal 'image/jpeg', job.content_type
+    assert_equal 'https://www.google.com/cloudprint/download?id=job_id', job.file_url
+    assert_equal 'https://www.google.com/cloudprint/ticket?jobid=job_id', job.ticket_url
+    assert_equal Time.at(1349722237.676), job.create_time
+    assert_equal Time.at(1349722237.676), job.update_time
+    assert_equal 'A message.', job.message
+    assert_equal ["^own"], job.tags
   end
 
   should 'recognize a job as queued' do
-    job = CloudPrint::PrintJob.new(:status => "QUEUED")
+    job = @client.print_jobs.new(:status => "QUEUED")
 
     assert !job.done?
     assert !job.in_progress?
@@ -39,7 +48,7 @@ class PrintJobTest < Test::Unit::TestCase
   end
 
   should 'recognize a job as in progress' do
-    job = CloudPrint::PrintJob.new(:status => "IN_PROGRESS")
+    job = @client.print_jobs.new(:status => "IN_PROGRESS")
 
     assert !job.done?
     assert !job.queued?
@@ -50,7 +59,7 @@ class PrintJobTest < Test::Unit::TestCase
   end
 
   should 'recognize a job as done' do
-    job = CloudPrint::PrintJob.new(:status => "DONE")
+    job = @client.print_jobs.new(:status => "DONE")
 
     assert !job.in_progress?
     assert !job.queued?
@@ -61,7 +70,7 @@ class PrintJobTest < Test::Unit::TestCase
   end
 
   should "recognize a job has an error" do
-    job = CloudPrint::PrintJob.new(:status => "ERROR")
+    job = @client.print_jobs.new(:status => "ERROR")
 
     assert !job.done?
     assert !job.in_progress?
@@ -72,7 +81,7 @@ class PrintJobTest < Test::Unit::TestCase
   end
 
   should "recognize a job as submitted" do
-    job = CloudPrint::PrintJob.new(:status => "SUBMITTED")
+    job = @client.print_jobs.new(:status => "SUBMITTED")
 
     assert !job.done?
     assert !job.in_progress?
@@ -83,8 +92,8 @@ class PrintJobTest < Test::Unit::TestCase
   end
 
   should "refresh a job" do
-    job = CloudPrint::PrintJob.new(:status => "IN_PROGRESS")
-    CloudPrint::PrintJob.stubs(:find_by_id).returns({"id" => "job_id", "status" => "DONE", "errorCode" => "42"})
+    job = @client.print_jobs.new(:id => "job_id", :status => "IN_PROGRESS")
+    @client.print_jobs.stubs(:find_by_id).returns({"id" => "job_id", "status" => "DONE", "errorCode" => "42"})
 
     assert_equal job, job.refresh!
 
@@ -92,13 +101,56 @@ class PrintJobTest < Test::Unit::TestCase
     assert_equal "42", job.error_code
   end
 
+  should "return all jobs" do
+    fake_connection.stubs(:get).with('/jobs').returns(jobs_response)
+    jobs = @client.print_jobs.all
+
+    assert jobs[0].id == 'other_job'
+    assert jobs[1].id == 'job_id'
+  end
+
+  context '#delete!' do
+    should "return true on success" do
+      fake_connection.stubs(:get).with('/deletejob', { :jobid => 'job_id' }).returns({ 'success' => true })
+
+      assert @client.print_jobs.new(:id => 'job_id').delete!
+    end
+
+    should "perform a remote request" do
+      fake_connection.expects(:get).with('/deletejob', { :jobid => 'job_id' }).returns({ 'success' => true })
+
+      @client.print_jobs.new(:id => 'job_id').delete!
+    end
+
+    should "raise a RequestError on failure" do
+      fake_connection.stubs(:get).with('/deletejob', { :jobid => 'job_id' }).returns({ 'success' => false, 'message' => 'This is an error', 'errorCode' => '123' })
+
+      assert_raise(CloudPrint::RequestError, 'This is an error') do
+        @client.print_jobs.new(:id => 'job_id').delete!
+      end
+    end
+  end
+
   private
 
   def jobs_response
     {
       "jobs" => [
-        {"id" => "other_job", "status" => "status", "errorCode" => "Error"},
-        {"id" => "job_id", "status" => "status", "errorCode" => "Error"}
+        { "id" => "other_job", "status" => "status", "errorCode" => "Error" },
+        {
+          "id" => "job_id",
+          "status" => "status",
+          "errorCode" => "Error",
+          "printerid" => "printer_id",
+          "title" => "Job Title",
+          "contentType" => "image/jpeg",
+          "fileUrl" => "https://www.google.com/cloudprint/download?id=job_id",
+          "ticketUrl" => "https://www.google.com/cloudprint/ticket?jobid=job_id",
+          "createTime" => "1349722237676",
+          "updateTime" => "1349722237676",
+          "message" => "A message.",
+          "tags" => ["^own"]
+        }
       ]
     }
   end