gmail-api-ruby 0.0.1 → 0.0.2

data/lib/gmail/draft.rb

@@ -10,7 +10,12 @@ module Gmail
       if @values.message.is_a?(Gmail::Message)
         @values.message
       else
-        @values.message = Util.convert_to_gmail_object(to_hash["message"], key="message").detailed
+        @values.message = Util.convert_to_gmail_object(to_hash[:message], key="message")
+        if @values.message.payload.nil?
+          self.detailed!
+          message
+        end
+        @values.message
       end
     end
 

data/lib/gmail/gmail_object.rb

@@ -40,16 +40,25 @@ module Gmail
     end
 
     def detailed
+      if self.class == Gmail::GmailObject
+        raise "Can't detail a generic GmailObject. It needs to be a Thread, Message, Draft or Label"
+      end
+
       self.class.get(id)
     end
 
-    def detailed!
+    def refresh
+      if self.class == Gmail::GmailObject
+        raise "Can't refresh a generic GmailObject. It needs to be a Thread, Message, Draft or Label"
+      end
       @values = self.class.get(id).values
       self
     end
+
+    alias_method :detailed!, :refresh
     #
     def to_hash
-      @values.to_hash
+      Util.symbolize_names(@values.to_hash)
     end
 
     def values

data/lib/gmail/label.rb

@@ -7,11 +7,11 @@ module Gmail
     include Gmail::Base::Update
 
     def save
-      update(@values.to_hash)
+      update(to_hash)
     end
 
     def save!
-      update!(@values.to_hash)
+      update!(to_hash)
     end
 
     def self.boxes

data/lib/gmail/message.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 module Gmail
   class Message < APIResource
     include Gmail::Base::List
@@ -93,10 +94,11 @@ module Gmail
         msg.to   = to
         msg.cc = cc
         msg.header['X-Bcc'] = bcc unless bcc.nil?#because Mail gem doesn't allow bcc headers...
-        msg.header['In-Reply-To'] = in_reply_to  unless in_reply_to.nil?
-        msg.header['References'] = references unless references.nil?
+        msg.in_reply_to = in_reply_to  unless in_reply_to.nil?
+        msg.references = references unless references.nil?
         if text
           msg.text_part = Mail::Part.new do |p|
+            content_type 'text/plain; charset=UTF-8'
             p.body s.text
           end
         end
@@ -106,7 +108,6 @@ module Gmail
             p.body s.html
           end
         end
-
         Base64.urlsafe_encode64 msg.to_s.sub("X-Bcc", "Bcc") #because Mail gem doesn't allow bcc headers...
       end
     end
@@ -171,11 +172,11 @@ module Gmail
         end
 
         if payload.parts
-          text_part=@values.payload.parts.select{|h| h.mimeType=="text/plain"}.first
+          text_part=@values.payload.find_all_object_containing("mimeType", "text/plain").first
           if text_part
             @values.text = urlsafe_decode64(text_part.body.data)
           end
-          html_part=@values.payload.parts.select{|h| h.mimeType=="text/html"}.first
+          html_part=@values.payload.find_all_object_containing("mimeType", "text/html").first
           if html_part
             @values.html = urlsafe_decode64(html_part.body.data)
           end
@@ -185,5 +186,22 @@ module Gmail
         end
       end
     end
+
+    class Hashie::Mash
+      def find_all_object_containing(key, value )
+        result=[]
+        if self.send(key) == value
+          result << self
+        end
+        self.values.each do |vs|
+          vs = [vs] unless vs.is_a? Array
+          vs.each do |v|
+            result += v.find_all_object_containing(key,value) if v.is_a? Hashie::Mash
+          end
+        end
+        result
+      end
+    end
+
   end
 end

data/lib/gmail/thread.rb

@@ -1,7 +1,6 @@
 module Gmail
   class Thread < APIResource
     include Gmail::Base::List
-    include Gmail::Base::Create
     include Gmail::Base::Delete
     include Gmail::Base::Get
     include Gmail::Base::Modify
@@ -9,9 +8,16 @@ module Gmail
 
     def messages
 
-      msgs = to_hash["messages"] || detailed.messages
-
-      Util.convert_to_gmail_object(msgs, key="message")
+      if @values.messages.is_a? Array
+        if @values.messages.first.is_a? Gmail::Message
+          @values.messages
+        else
+          @values.messages = Util.convert_to_gmail_object(to_hash[:messages], key="message")
+        end
+      else
+        self.detailed!
+        messages
+      end
 
     end
 

data/lib/gmail/version.rb

@@ -1,3 +1,3 @@
 module Gmail
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end # Gmail

data/test/gmail/api_resource_test.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Gmail
+  class ApiResourceTest < Test::Unit::TestCase
+
+    should "creating a new APIResource should not fetch over the network" do
+      @mock.expects(:execute).never
+      Gmail::Label.new({
+                                          name: "test"
+                                      })
+    end
+
+    should "setting an attribute should not cause a network request" do
+      @mock.expects(:execute).never
+      m = Gmail::Message.new({subject: "test"})
+      m.body = "this is a test body"
+    end
+
+    should "accessing id should not issue a fetch" do
+      @mock.expects(:execute).never
+      c = Gmail::Message.new({subject: "test"})
+      c.id
+    end
+
+    should "construct URL properly with base query parameters" do
+      response = test_response(test_thread_list)
+      @mock.expects(:execute).with(api_method: Gmail.service.users.threads.list, parameters: {userId: "me"}, headers: {'Content-Type' => 'application/json'}).returns(response)
+      Gmail::Thread.all
+
+      @mock.expects(:execute).with(api_method: Gmail.service.users.threads.list, parameters: {maxResults: 150, userId: "test@test.com"}, headers: {'Content-Type' => 'application/json'}).returns(response)
+      Gmail::Thread.all(maxResults: 150, userId: "test@test.com")
+    end
+
+
+    should "deleting should return true" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.delete, parameters: {userId: "me", id: test_draft[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(""))
+
+      d = Gmail::Draft.new test_draft
+
+      assert_equal true, d.delete
+
+    end
+
+
+  end
+end

data/test/gmail/draft_test.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Gmail
+  class DraftTest < Test::Unit::TestCase
+
+    should "Draft should be retrievable by id" do
+
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.get, parameters: {userId: "me", id: test_draft[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_draft))
+      d = Gmail::Draft.get(test_draft[:id])
+      assert d.kind_of?Gmail::Draft
+      assert_equal test_draft[:id], d.id
+    end
+
+    should "drafts should be listable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.list, parameters: {userId: "me"}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_draft_list))
+      list = Gmail::Draft.all
+      assert list.kind_of? Array
+      assert list[0].kind_of? Gmail::Draft
+    end
+
+  context "Message Object in draft" do
+    should "retrieved Draft should not generate call to get Message Object" do
+      draft = Gmail::Draft.new(test_draft)
+      @mock.expects(:execute).never
+      assert draft.message.kind_of?Gmail::Message
+    end
+
+    should "Draft get from a draft list should generate call to get Message Object" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.list, parameters: {userId: "me"}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_draft_list))
+      list = Gmail::Draft.all
+      draft = list.first
+
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.get, parameters: {userId: "me", id: test_draft[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_draft))
+
+      assert draft.message.kind_of?Gmail::Message
+      assert_not_nil draft.message.payload
+    end
+  end
+
+
+    should "drafts should be deletable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.delete, parameters: {userId: "me", id: test_draft[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(""))
+      d = Gmail::Draft.new(test_draft)
+      r = d.delete
+      assert r
+    end
+
+    should "drafts should be updateable" do
+      draft_hash = test_draft
+      draft_hash[:message].merge!({labelIds: ["COOL LABEL"]})
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.get, parameters: {id: test_draft[:id], userId: "me"} , headers: {'Content-Type' => 'application/json'}).once.returns(test_response(draft_hash))
+
+      d = Gmail::Draft.new(id: test_draft[:id]).detailed
+      # those two lines are required because raw generation change between two calls...
+      raw = d.message.raw
+      d.message.raw = raw
+      ###
+      assert_equal ["COOL LABEL"], d.message.labelIds
+
+      draft_hash[:message].merge!({labelIds: ["INBOX"]})
+
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.update, parameters: {id: test_draft[:id], userId: "me"}, body_object:{message: {raw: d.message.raw, threadId: test_draft[:message][:threadId], labelIds: ["INBOX"]}} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(draft_hash))
+
+
+      d.message.labelIds = ["INBOX"]
+      new_d = d.save
+      assert_equal ["INBOX"], new_d.message.labelIds
+      assert_not_equal d.object_id, new_d.object_id
+      new_d = d.save!
+      assert_equal d.object_id, new_d.object_id
+    end
+
+    should "create should return a new Draft" do
+      draft_hash = test_draft
+      draft_hash.delete(:id)
+      d = Gmail::Draft.new draft_hash
+      # those two lines are required because raw generation change between two calls...
+      raw = d.message.raw
+      d.message.raw = raw
+      ###
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.create, parameters: {userId: "me"}, body_object:{message: {raw: d.message.raw, threadId: draft_hash[:message][:threadId], labelIds: draft_hash[:message][:labelIds]}} , headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_draft))
+      created_d = d.save!
+      assert_equal Gmail::Draft, created_d.class
+      assert_equal test_draft[:id], d.id
+    end
+
+
+    should "Draft should be sendable and return a Message" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.to_h['gmail.users.drafts.send'], parameters: {userId: "me"}, body_object:{id: test_draft[:id]} , headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message))
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.get, parameters: {userId: "me", id: test_message[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message))
+
+      d = Gmail::Draft.new test_draft
+      m = d.deliver
+
+      assert m.kind_of?Gmail::Message
+
+    end
+
+
+
+
+  end
+end

data/test/gmail/gmail_object_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Gmail
+  class GmailObjectTest < Test::Unit::TestCase
+    should "implement #respond_to correctly" do
+      obj = Gmail::GmailObject.new({ :id => 1, :foo => 'bar' })
+      assert_not_nil obj.id
+      assert_not_nil obj.foo
+      assert_nil obj.other
+    end
+
+    should "detail and refresh a Gmail object correctly" do
+      obj = Gmail::GmailObject.new test_message
+      exception = assert_raise do obj.refresh end
+      assert_equal "Can't refresh a generic GmailObject. It needs to be a Thread, Message, Draft or Label", exception.message
+      exception  = assert_raise do obj.detailed end
+      assert_equal "Can't detail a generic GmailObject. It needs to be a Thread, Message, Draft or Label", exception.message
+
+      not_generic_object = Gmail::Message.new test_message
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.get, parameters: {userId: "me", id: test_message[:id]}, headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+
+      new_o = not_generic_object.detailed
+      assert_not_equal new_o.object_id, not_generic_object.object_id
+
+      new_o = not_generic_object.refresh
+      assert_equal new_o.object_id, not_generic_object.object_id
+
+    end
+
+    should "not recursively call to_hash on GmailObject" do
+      nested = Gmail::GmailObject.new({ :id => 7, :foo => 'bar' })
+      obj = Gmail::GmailObject.new({ :id => 1, :nested => nested })
+      expected_hash = { :id => 1, :nested => nested }
+      assert_equal expected_hash, obj.to_hash
+    end
+
+    should "recursively call to_hash on its value" do
+      nested = { :id => 7, :foo => 'bar' }
+      obj = Gmail::GmailObject.new({ :id => 1, :nested => nested })
+      expected_hash = { :id => 1, :nested => nested }
+      assert_equal 7, obj.nested.id
+      assert_equal expected_hash, obj.to_hash
+    end
+  end
+end

data/test/gmail/label_test.rb

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Gmail
+  class LabelTest < Test::Unit::TestCase
+
+    should "Labels should be listable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.labels.list, parameters: {userId: "me"}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_label_list))
+      list = Gmail::Label.all
+      assert list.kind_of? Array
+      assert list[0].kind_of? Gmail::Label
+    end
+
+
+    context "Retrieve a Label" do
+      should "Label should be retrievable by id" do
+
+        @mock.expects(:execute).with(api_method: Gmail.service.users.labels.get, parameters: {userId: "me", id: test_label[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_label))
+        l = Gmail::Label.get(test_label[:id])
+        assert l.kind_of?Gmail::Label
+        assert_equal test_label[:id], l.id
+      end
+
+
+      [:inbox, :sent, :trash, :important, :starred, :draft, :spam, :unread, :category_updates, :category_promotions, :category_social, :category_personal, :category_forums ].each do |label_id|
+        should "System Label should be retrievable by calling #{label_id.to_s}" do
+          @mock.expects(:execute).with(api_method: Gmail.service.users.labels.get, parameters: {userId: "me", id: label_id.to_s.upcase}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_label_list[:labels].select{|l| l[:id] == label_id.to_s.upcase}.first))
+          l = Gmail::Label.send(label_id.to_s)
+          assert l.kind_of?Gmail::Label
+          assert_equal label_id.to_s.upcase, l.id
+        end
+      end
+
+    end
+
+
+    context "Access list of Messages from Label" do
+      should "Access list of Messages" do
+        label = Gmail::Label.new test_label
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.list, parameters: {userId: "me", labelIds: [test_label[:id]]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message_list))
+        list = label.messages
+        assert list.kind_of? Array
+        assert list[0].kind_of? Gmail::Message
+      end
+
+      should 'Access list of unread Messages' do
+        label = Gmail::Label.new test_label
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.list, parameters: {userId: "me", labelIds: [test_label[:id], "UNREAD"]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message_list))
+        list = label.unread_messages
+        assert list.kind_of? Array
+        assert list[0].kind_of? Gmail::Message
+      end
+
+      should 'Access filtered Messages' do
+        label = Gmail::Label.new test_label
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.list, parameters: {userId: "me", labelIds: ["IMPORTANT", "COOL", test_label[:id]], threadId: "1"}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message_list))
+        list = label.messages(threadId: "1", labelIds: ["IMPORTANT", "COOL"])
+        assert list.kind_of? Array
+        assert list[0].kind_of? Gmail::Message
+      end
+
+      should "Access list of Threads" do
+        label = Gmail::Label.new test_label
+        @mock.expects(:execute).with(api_method: Gmail.service.users.threads.list, parameters: {userId: "me", labelIds: [test_label[:id]]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_thread_list))
+        list = label.threads
+        assert list.kind_of? Array
+        assert list[0].kind_of? Gmail::Thread
+      end
+
+      should 'Access list of unread Threads' do
+        label = Gmail::Label.new test_label
+        @mock.expects(:execute).with(api_method: Gmail.service.users.threads.list, parameters: {userId: "me", labelIds: [test_label[:id], "UNREAD"]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_thread_list))
+        list = label.unread_threads
+        assert list.kind_of? Array
+        assert list[0].kind_of? Gmail::Thread
+      end
+
+      should 'Access filtered Threads' do
+        label = Gmail::Label.new test_label
+        @mock.expects(:execute).with(api_method: Gmail.service.users.threads.list, parameters: {userId: "me", labelIds: ["IMPORTANT", "COOL", test_label[:id]], threadId: "1"}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_thread_list))
+        list = label.threads(threadId: "1", labelIds: ["IMPORTANT", "COOL"])
+        assert list.kind_of? Array
+        assert list[0].kind_of? Gmail::Thread
+      end
+
+
+
+    end
+
+
+    should "Label should be deletable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.labels.delete, parameters: {userId: "me", id: test_label[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(""))
+      d = Gmail::Label.new(test_label)
+      r = d.delete
+      assert r
+    end
+
+    should "Label should be updateable" do
+
+      label = Gmail::Label.new test_label(:messageListVisibility=>"show")
+
+      assert_equal "show", label.messageListVisibility
+
+
+      @mock.expects(:execute).with(api_method: Gmail.service.users.labels.update, parameters: {id: test_label[:id], userId: "me"}, body_object:test_label(:messageListVisibility=>"hide") , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_label(:messageListVisibility=>"hide")))
+
+      label.messageListVisibility = "hide"
+      new_l = label.save
+      assert_equal "hide", new_l.messageListVisibility
+      assert_not_equal label.object_id, new_l.object_id
+      new_l = label.save!
+      assert_equal label.object_id, new_l.object_id
+    end
+
+    should "create should return a new Label" do
+      label_hash = test_label
+      label_hash.delete(:id)
+      label = Gmail::Label.new label_hash
+      @mock.expects(:execute).with(api_method: Gmail.service.users.labels.create, parameters: {userId: "me"}, body_object:label_hash , headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_label))
+      created_l = label.save!
+      assert_equal Gmail::Label, created_l.class
+      assert_equal test_label[:id], label.id
+    end
+
+
+
+
+  end
+end