google-gmail-api 0.0.14

data/lib/gmail/thread.rb

@@ -0,0 +1,38 @@
+module Gmail
+  class Thread < APIResource
+    include Base::List
+    include Base::Delete
+    include Base::Get
+    include Base::Modify
+    include Base::Trash
+
+    def messages
+
+      if @values.messages.is_a? Array
+        if @values.messages.first.is_a? Message
+          @values.messages
+        else
+          @values.messages = Util.convert_to_gmail_object(to_hash[:messages], key="message")
+        end
+      else
+        self.detailed!
+        messages
+      end
+
+    end
+
+    def unread_messages
+
+      messages.select{|m| m.unread?}
+
+    end
+
+
+    def sent_messages
+
+      messages.select{|m| m.sent?}
+
+    end
+
+  end
+end

data/lib/gmail/util.rb

@@ -0,0 +1,45 @@
+module Gmail
+  module Util
+
+    def self.object_classes
+      @object_classes ||= {
+          # data structures
+
+          # business objects
+          'draft' => Draft,
+          'label' => Label,
+          'message' => Message,
+          'thread' => Thread
+      }
+    end
+
+    def self.convert_to_gmail_object(resp, key=nil)
+      case resp
+        when Array
+          resp.map { |i| convert_to_gmail_object(i, key) }
+        when Hash
+          # Try converting to a known object class.  If none available, fall back to generic StripeObject
+          object_classes.fetch(key , GmailObject).new(resp)
+        else
+          resp
+      end
+    end
+
+
+    def self.symbolize_names(object)
+      case object
+        when Hash
+          new_hash = {}
+          object.each do |key, value|
+            key = (key.to_sym rescue key) || key
+            new_hash[key] = symbolize_names(value)
+          end
+          new_hash
+        when Array
+          object.map { |value| symbolize_names(value) }
+        else
+          object
+      end
+    end
+  end
+end

data/lib/gmail/version.rb

@@ -0,0 +1,3 @@
+module Gmail
+  VERSION = "0.0.14"
+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,39 @@
+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 "recursively call to_hash on GmailObject" do
+      nested = Gmail::GmailObject.new({ :id => 7, :foo => 'bar' })
+      obj = Gmail::GmailObject.new({ :id => 1})
+      obj.nested = nested
+      expected_hash = { :id => 1, :nested => {:id => 7, :foo => 'bar'} }
+      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

data/test/gmail/message_test.rb

@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+# encoding: utf-8
+require File.expand_path('../../test_helper', __FILE__)
+
+module Gmail
+  class MessageTest < Test::Unit::TestCase
+
+    should "messages should be listable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.list, parameters: {userId: "me"}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message_list))
+      list = Gmail::Message.all
+      assert_equal Array, list.class
+      assert_equal Gmail::Message, list[0].class
+    end
+
+    should "message should be retrievable by id" do
+
+      @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))
+      t = Gmail::Message.get(test_message[:id])
+      assert_equal Gmail::Message, t.class
+      assert_equal test_message[:id], t.id
+    end
+
+    should "message construct should set some basics values" do
+
+      m = Gmail::Message.new(test_message)
+      ["From", "To", "Cc", "Subject", "Bcc", "Date", "Message-ID", "References", "In-Reply-To", "Delivered-To"].each do |method|
+        assert_equal test_message[:payload][:headers].select{|h| h[:name].downcase == method.downcase}.first[:value], m.send(method.downcase.tr("-", "_"))
+      end
+      assert_not_nil m.text || m.body || m.html
+
+    end
+
+    should "message (with strange format) construct should set at least body, text or html" do
+
+      m = Gmail::Message.new(test_strange_message)
+      assert_not_nil m.text || m.body || m.html
+
+    end
+
+
+
+
+    should "Access thread from message" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.threads.get, parameters: {userId: "me", id: test_message[:threadId]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_thread))
+      m = Gmail::Message.new(test_message)
+      t = m.thread
+      assert_equal test_message[:threadId], m.thread_id
+      assert_equal Gmail::Thread, t.class
+    end
+
+    should "message should be deletable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.delete, parameters: {userId: "me", id: test_message[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(""))
+      t = Gmail::Message.new(test_message)
+      r = t.delete
+      assert r
+    end
+
+    should "message should be thrashable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.trash, parameters: {userId: "me", id: test_message[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message))
+      t = Gmail::Message.new(test_message)
+      r = t.trash
+      assert_equal Gmail::Message, r.class
+    end
+
+    should "message should be unthrashable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.untrash, parameters: {userId: "me", id: test_message[:id]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message))
+      t = Gmail::Message.new(test_message)
+      r = t.untrash
+      assert_equal Gmail::Message, r.class
+    end
+
+    context "Modifying Labels" do
+      should "message should be starrable" do
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.modify, parameters: {userId: "me", id: test_message[:id]}, body_object: {addLabelIds: ["STARRED"], removeLabelIds: []} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+        t = Gmail::Message.new(test_message)
+        r = t.star
+        assert_equal Gmail::Message, r.class
+        assert_not_equal t.object_id, r.object_id
+
+        r = t.star!
+
+        assert_equal t.object_id, r.object_id
+
+      end
+
+      should "message should be unstarrable" do
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.modify, parameters: {userId: "me", id: test_message[:id]}, body_object: {addLabelIds: [], removeLabelIds: ["STARRED"]} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+        t = Gmail::Message.new(test_message)
+        r = t.unstar
+        assert_equal Gmail::Message, r.class
+
+        assert_not_equal t.object_id, r.object_id
+
+        r = t.unstar!
+
+        assert_equal t.object_id, r.object_id
+      end
+
+      should "message should be archivable" do
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.modify, parameters: {userId: "me", id: test_message[:id]}, body_object: {addLabelIds: [], removeLabelIds: ["INBOX"]} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+        t = Gmail::Message.new(test_message)
+        r = t.archive
+        assert_equal Gmail::Message, r.class
+        assert_not_equal t.object_id, r.object_id
+
+        r = t.archive!
+
+        assert_equal t.object_id, r.object_id
+      end
+
+      should "message should be unarchivable" do
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.modify, parameters: {userId: "me", id: test_message[:id]}, body_object: {addLabelIds: ["INBOX"], removeLabelIds: []} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+        t = Gmail::Message.new(test_message)
+        r = t.unarchive
+        assert_equal Gmail::Message, r.class
+        assert_not_equal t.object_id, r.object_id
+
+        r = t.unarchive!
+
+        assert_equal t.object_id, r.object_id
+      end
+
+      should "message should be markable as read" do
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.modify, parameters: {userId: "me", id: test_message[:id]}, body_object: {addLabelIds: [], removeLabelIds: ["UNREAD"]} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+        t = Gmail::Message.new(test_message)
+        r = t.mark_as_read
+        assert_equal Gmail::Message, r.class
+        assert_not_equal t.object_id, r.object_id
+
+        r = t.mark_as_read!
+
+        assert_equal t.object_id, r.object_id
+      end
+
+      should "message should be markable as unread" do
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.modify, parameters: {userId: "me", id: test_message[:id]}, body_object: {addLabelIds: ["UNREAD"], removeLabelIds: []} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+        t = Gmail::Message.new(test_message)
+        r = t.mark_as_unread
+        assert_equal Gmail::Message, r.class
+        assert_not_equal t.object_id, r.object_id
+
+        r = t.mark_as_unread!
+
+        assert_equal t.object_id, r.object_id
+      end
+
+
+      should "message label should be modifiable as wish" do
+        @mock.expects(:execute).with(api_method: Gmail.service.users.messages.modify, parameters: {userId: "me", id: test_message[:id]}, body_object: {addLabelIds: ["UNREAD", "SOME COOL LABEL"], removeLabelIds: ["INBOX", "SOME NOT COOL LABEL"]} , headers: {'Content-Type' => 'application/json'}).twice.returns(test_response(test_message))
+        t = Gmail::Message.new(test_message)
+        r = t.modify ["UNREAD", "SOME COOL LABEL"], ["INBOX", "SOME NOT COOL LABEL"]
+        assert_equal Gmail::Message, r.class
+        assert_not_equal t.object_id, r.object_id
+
+        r = t.modify! ["UNREAD", "SOME COOL LABEL"], ["INBOX", "SOME NOT COOL LABEL"]
+
+        assert_equal t.object_id, r.object_id
+      end
+
+    end
+
+
+    should "Helpers should work" do
+      m = Gmail::Message.new test_message
+      assert_false m.sent?
+      assert_false m.inbox?
+      assert_false m.unread?
+      m = Gmail::Message.new test_inbox_message
+      assert_false m.sent?
+      assert m.inbox?
+      assert_false m.unread?
+      m = Gmail::Message.new test_sent_message
+      assert m.sent?
+      assert_false m.inbox?
+      assert_false m.unread?
+      m = Gmail::Message.new test_unread_message
+      assert_false m.sent?
+      assert_false m.inbox?
+      assert m.unread?
+    end
+
+
+    should "Message should be searcheable" do
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.list, parameters: {userId: "me", q: "from:(me) to:(you) subject:(subject) in:inbox before:2014/12/1 after:2014/11/1 test -{real}", labelIds:["UNREAD"]}, headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_message_list))
+      list = Gmail::Message.search(from:"me", to: "you", subject: "subject", in: "inbox", before: "2014/12/1", after: "2014/11/1", has_words: "test", has_not_words: "real", labelIds: ["UNREAD"])
+      assert_equal Array, list.class
+      assert_equal Gmail::Message, list[0].class
+    end
+
+    should "Message should construct RAW string correctly" do
+      m = Gmail::Message.new test_message
+      raw = Mail.new(Base64.urlsafe_decode64(m.raw))
+      assert raw.from
+      assert raw.to
+      assert raw.cc
+      assert_equal m.bcc, raw.header['Bcc'].value
+      assert_equal m.subject, raw.subject
+      assert_equal m.in_reply_to, "<#{raw.in_reply_to}>"
+      assert_equal m.references.tr("<", "").tr(">", "").split(" "), raw.references
+      assert raw.text_part.body.raw_source
+      assert raw.html_part.body.raw_source
+    end
+
+    should "Draft can be created from Message" do
+      m = Gmail::Message.new test_message
+      # raw generation change between two calls because date won't be the same...
+      m.raw = m.raw
+      ###
+      @mock.expects(:execute).with(api_method: Gmail.service.users.drafts.create, parameters: {userId: "me"}, body_object:{message: {raw: m.raw, threadId: test_message[:threadId], labelIds: test_message[:labelIds]}} , headers: {'Content-Type' => 'application/json'}).once.returns(test_response(test_draft))
+      d = m.create_draft
+      assert_equal Gmail::Draft, d.class
+
+    end
+
+    should "Message should be sendable and return a Message" do
+
+      m = Gmail::Message.new test_message
+      m.raw = m.raw
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.to_h['gmail.users.messages.send'], parameters: {userId: "me"}, body_object:{raw: m.raw, labelIds: test_message[:labelIds], threadId: test_message[:threadId]} , headers: {'Content-Type' => 'application/json'}).twice.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'}).twice.returns(test_response(test_message))
+
+
+      new_m = m.deliver
+      assert_equal Gmail::Message, new_m.class
+      assert_not_equal new_m.object_id, m.object_id
+
+      new_m = m.deliver!
+      assert_equal Gmail::Message, new_m.class
+      assert_equal new_m.object_id, m.object_id
+    end
+
+
+    should "Reply to sender contruct should be easy" do
+      m = Gmail::Message.new test_to_reply_message
+      reply_message = Gmail::Message.new test_reply_message
+      @mock.expects(:execute).never
+      expected_msg = Gmail::Message.new test_replied_message
+      new_m = m.reply_sender_with reply_message
+
+      assert_equal expected_msg.to, new_m.to
+      assert_nil new_m.cc
+      assert_nil new_m.bcc
+      assert_equal expected_msg.subject, new_m.subject
+      assert_equal expected_msg.references, new_m.references
+      assert_equal expected_msg.in_reply_to, new_m.in_reply_to
+      assert_equal expected_msg.thread_id, new_m.thread_id
+      assert_equal expected_msg.body, new_m.body
+      assert_nil new_m.html
+      assert_nil new_m.text
+
+      new_m = m.reply_sender_with(Gmail::Message.new test_reply_message_with_html)
+      expected_msg = Gmail::Message.new(test_replied_message_with_html)
+
+      assert_equal expected_msg.text, new_m.text
+      assert_equal expected_msg.html, new_m.html
+      assert_nil new_m.body
+
+    end
+
+    should "Reply to all construct should be easy" do
+      m = Gmail::Message.new test_to_reply_message
+      reply_message = Gmail::Message.new test_reply_message
+      @mock.expects(:execute).never
+      new_m = m.reply_all_with reply_message
+      expected_msg = Gmail::Message.new test_replied_message
+
+      assert_equal expected_msg.to, new_m.to
+      assert_equal expected_msg.cc, new_m.cc
+      assert_nil new_m.bcc
+      assert_equal expected_msg.subject, new_m.subject
+      assert_equal expected_msg.references, new_m.references
+      assert_equal expected_msg.in_reply_to, new_m.in_reply_to
+      assert_equal expected_msg.thread_id, new_m.thread_id
+      assert_equal expected_msg.body, new_m.body
+      assert_nil new_m.html
+      assert_nil new_m.text
+
+      new_m = m.reply_all_with(Gmail::Message.new test_reply_message_with_html)
+      expected_msg = Gmail::Message.new(test_replied_message_with_html)
+
+      assert_equal expected_msg.text, new_m.text
+      assert_equal expected_msg.html, new_m.html
+      assert_nil new_m.body
+
+
+    end
+
+    should "Construct correctly set_headers_for_reply" do
+      m = Gmail::Message.new({body: ""})
+      m.from = "\"John, Malkovich\" john@malkovich.com"
+      m.to = "\"Julie, Desk\"julie@juliedesk.com, \"Judith, Desk\"judith@juliedesk.com"
+      m.delivered_to = "julie@juliedesk.com"
+      new_msg = m.send(:set_headers_for_reply, Gmail::Message.new({body: ""}))
+
+      #assert_equal new_msg.from, "\"Julie, Desk\"julie@juliedesk.com"
+      assert_equal new_msg.to, "\"John, Malkovich\" john@malkovich.com"
+      assert_equal new_msg.cc, "\"Judith, Desk\"judith@juliedesk.com"
+    end
+
+    should "Reply to all construct should be easy and call getProfile if delivered_to is not set" do
+      m = Gmail::Message.new test_to_reply_message2
+      reply_message = Gmail::Message.new test_reply_message
+      @mock.expects(:execute).with(api_method: Gmail.service.users.to_h['gmail.users.getProfile'],parameters: {userId: "me"} , headers: {'Content-Type' => 'application/json'}).once.returns(test_response({emailAddress: "julie@juliedesk.com"}))
+      new_m = m.reply_all_with reply_message
+      expected_msg = Gmail::Message.new test_replied_message
+
+      assert_equal expected_msg.to, new_m.to
+      assert_equal expected_msg.cc, new_m.cc
+      assert_nil new_m.bcc
+      assert_equal expected_msg.subject, new_m.subject
+      assert_equal expected_msg.references, new_m.references
+      assert_equal expected_msg.in_reply_to, new_m.in_reply_to
+      assert_equal expected_msg.thread_id, new_m.thread_id
+      assert_equal expected_msg.body, new_m.body
+      assert_nil new_m.html
+      assert_nil new_m.text
+
+
+    end
+
+    should "forward construct should be easy" do
+      m = Gmail::Message.new test_to_reply_message
+      forward_message = Gmail::Message.new(test_forward_message)
+      @mock.expects(:execute).never
+      new_m = m.forward_with forward_message
+      expected_msg = Gmail::Message.new test_forwarded_message
+      # to be completed to be fully tested
+
+      assert_equal expected_msg.to, new_m.to
+      assert_equal expected_msg.cc, new_m.cc
+      assert_nil new_m.bcc
+      assert_equal expected_msg.subject, new_m.subject
+      assert_equal expected_msg.references, new_m.references
+      assert_equal expected_msg.in_reply_to, new_m.in_reply_to
+      assert_equal expected_msg.thread_id, new_m.thread_id
+      assert_equal expected_msg.body, new_m.body
+      assert_nil new_m.html
+      assert_nil new_m.text
+
+      forward_message = Gmail::Message.new({to: "test@test.com", bbc: "coucou", cc: "test@couocu.com, second@second.com", subject: "cool subject", html: "<b>test</b>", text: "test"})
+      new_m = m.forward_with forward_message
+      expected_msg = Gmail::Message.new test_forwarded_message_with_html
+
+      assert_equal expected_msg.text, new_m.text
+      assert_equal expected_msg.html, new_m.html
+      assert_nil new_m.body
+    end
+
+    should "Insert call should be easy" do
+      m = Gmail::Message.new test_message
+      m.raw = m.raw
+      @mock.expects(:execute).with(api_method: Gmail.service.users.messages.insert, parameters: {userId: "me"}, body_object:{raw: m.raw, labelIds: test_message[:labelIds], threadId: test_message[:threadId]} , headers: {'Content-Type' => 'application/json'} ).twice.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'}).twice.returns(test_response(test_message))
+
+
+      new_m = m.insert
+
+      assert_not_equal m.object_id, new_m.object_id
+      new_m = m.insert!
+      assert_equal m.object_id, new_m.object_id
+    end
+
+  end
+end