gcevent 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ed80a14b297c92273c4d98fd0453093b28933930
+  data.tar.gz: 2e91a47896486ffc72ed2bd2bf2c4fe24434670c
+SHA512:
+  metadata.gz: 846f687faae6f667d2fd52265c4edda0769f470069fe4564d518d932420315234bb6bfe59b07ab99efaaa2f46b68230bfe80447bb7996bfe2d8bd0672695e8a6
+  data.tar.gz: ca595b052140336f8e529cee6a899d9c637003ec3bf3e411b1bf7f5ec188bc41d4fc4af6ed5f48085397f01cbe64ea47d6b69827417929b507a1616d79e99ebc

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-*
+/vendor/

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.5
+  - 2.1.6
+  - 2.2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gcevent.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 ogawatti
+
+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,128 @@
+[![Build Status](https://travis-ci.org/ogawatti/gcevent.svg?branch=master)](https://travis-ci.org/ogawatti/gcevent)
+[![Coverage Status](https://coveralls.io/repos/ogawatti/gcevent/badge.png?branch=master)](https://coveralls.io/r/ogawatti/gcevent?branch=master)
+[<img src="https://gemnasium.com/ogawatti/gcevent.png" />](https://gemnasium.com/ogawatti/gcevent)
+
+# Gcevent
+
+A wrapper of Google Calendar Event API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gcevent'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gcevent
+
+## Usage
+
+### Calendar Setting
+
+```ruby
+Google::Calendar.id                  = "Id of a target Google Calendar"
+Google::Calendar.secret_key.path     = "Path of xxx-privatekey.p12"
+Google::Calendar.secret_key.password = "Password"
+Google::Calendar.client_id           = "ID of Client"
+```
+
+### Event#get
+
+```ruby
+event_id = "Google Calendar Event ID"
+event = Google::Calendar::Event.get(event_id)
+```
+
+or
+
+```ruby
+event = Google::Calendar::Event.new(event_id: event_id)
+event.fetch
+```
+
+### Event#list
+
+specified date or time
+
+```ruby
+start_date = Date.today.beginning_of_week
+end_date   = Date.today.end_of_week
+events = Google::Calendar::Event.list(start_time, end_time)
+```
+
+today or this week or ...
+
+
+```ruby
+Google::Calendar::Event.today
+Google::Calendar::Event.tomorrow
+Google::Calendar::Event.yesterday
+Google::Calendar::Event.this_week
+Google::Calendar::Event.this_month
+Google::Calendar::Event.this_year
+```
+
+### Event#insert
+
+```ruby
+event = Google::Calendar::Event.new
+event.summary = "Inserted #{Time.now}"
+event.start   = { dateTime: Date.today.to_time.utc.iso8601 }
+event.end     = { dateTime: Date.tomorrow.to_time.utc.iso8601 }
+event.insert
+```
+
+or
+
+```ruby
+options = { summary: "Inserted #{Time.now}",
+start:   { date: Date.today },
+end:     { date: Date.tomorrow } }
+event = Google::Calendar::Event.insert(options)
+```
+
+### Event#quickAdd
+
+quick insert
+
+```ruby
+text = "Quick Added"
+event = Google::Calendar::Event.quickAdd(text)
+```
+
+### Event#update
+
+```ruby
+event = Google::Calendar::Event.this_week.last
+event.summary = "Updated #{Time.now}"
+event.update
+```
+
+# Delete Phase
+
+```ruby
+event = Google::Calendar::Event.this_week.first
+event.delete
+```
+
+or
+
+```ruby
+event = Google::Calendar::Event.this_week.last
+Google::Calendar::Event.delete(event.id)
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/gcevent/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/gcevent.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "gcevent"
+  spec.version       = "0.0.1"
+  spec.authors       = ["ogawatti"]
+  spec.email         = ["ogawattim@gmail.com"]
+  spec.summary       = %q{A wrapper of Google Calendar Event API.}
+  spec.description   = %q{}
+  spec.homepage      = "https://github.com/ogawatti/gcevent"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency "google-api-client"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "hashie"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+end

data/lib/gcevent.rb

@@ -0,0 +1,4 @@
+require "google/calendar"
+
+module Gcevent
+end

data/lib/google/calendar.rb

@@ -0,0 +1,67 @@
+require 'google/service_account'
+require 'google/calendar/event'
+require 'google/api_client'
+require 'hashie'
+
+module Google
+  class SecretKey < Hashie::Mash; end
+
+  module Calendar
+    class << self
+      attr_accessor :id, :client_id
+    end
+
+    extend self
+
+    def api
+      authorize unless authorized?
+      client.discovered_api('calendar', 'v3')
+    end
+
+    def client
+      @client ||= Google::APIClient.new(:application_name => '')
+    end
+
+    def authorize
+      raise Errno::ENOENT.new(secret_key.path) unless File.exist?(secret_key.path)
+      client.authorization = Signet::OAuth2::Client.new(
+        token_credential_uri: service_account.token_uri,
+        audience:             service_account.token_uri,
+        scope:                service_account.scope,
+        issuer:               service_account.client_email,
+        signing_key:          signing_key
+      )
+      client.authorization.fetch_access_token!
+      @authorized = true
+    end
+
+    def secret_key
+      @secret_key ||= Google::SecretKey.new({ path: nil, password: nil })
+    end
+
+    def service_account
+      Google::ServiceAccount.new(client_id)
+    end
+
+    def signing_key
+      Google::APIClient::KeyUtils.load_from_pkcs12(secret_key.path, secret_key.password)
+    end
+
+    def authorized?
+      @authorized
+    end
+
+    # MEMO : body_objectでなくbodyを使う
+    #  * 公式のReference的にはbody_object
+    #   * body_objectを空文字指定でEvent#getすると400 Bad Request
+    #   * 必要ないときはパラメータに含めない方がよさそう
+    #  * bodyパラメータなら空文字指定でもOK
+    def execute(api_method, parameters={}, body="")
+      options = { api_method:  api_method,
+                  parameters:  parameters,
+                  body:        body,
+                  headers: { 'Content-Type' => 'application/json' } }
+      client.execute!(options)
+    end
+  end
+end

data/lib/google/calendar/errors.rb

@@ -0,0 +1,7 @@
+module Google
+  module Calendar
+    class Errors
+      class Error < StandardError; end
+    end
+  end
+end

data/lib/google/calendar/event.rb

@@ -0,0 +1,192 @@
+require 'hashie'
+require 'active_support'
+require 'active_support/core_ext'
+
+module Google
+  module Calendar
+    class Event
+      # API Reference
+      #  * https://developers.google.com/google-apps/calendar/v3/reference/#Events
+      #
+      # Supported Google Calendar API (Events)
+      #   Method    VERB    PATH
+      #   --------  ------  --------------------------------------
+      #   get       GET     /calendars/:calendarId/events/:eventId
+      #   list      GET     /calendars/:calendarId/events
+      #   insert    POST    /calendars/:calendarId/events
+      #   delete    DELETE  /calendars/:calendarId/events/:eventId
+      #   quickAdd  POST    /calendars/:calendarId/events/quickAdd
+      #   update    PUT     /calendars/:calendarId/events/:eventId
+
+      attr_reader   :id, :kind, :etag, :status, :htmlLink, :created, :updated
+      attr_reader   :creator, :organizer, :transparency, :iCalUID, :sequence, :reminders
+      attr_accessor :summary, :start, :end
+      def initialize(options={})
+        update_attributes(options)
+      end
+
+      # [API] get
+      #   GET /calendars/:calendarId/events/eventId
+      def self.get(id)
+        self.new(id: id).fetch
+      end
+
+      def fetch
+        params  = { calendarId: Calendar.id, eventId: id }
+        request(Calendar.api.events.get, params)
+      end
+
+      # [API] list
+      #   GET /calendars/:calendarId/events
+      def self.list(st, et)
+        params = { calendarId:   Calendar.id,
+                   orderBy:      'startTime',
+                   timeMax:      et.to_time.utc.iso8601,
+                   timeMin:      st.to_time.utc.iso8601,
+                   singleEvents: 'True' }
+        request(Calendar.api.events.list, params)
+      end
+
+      # [API] insert
+      #   POST /calendars/:calendarId/events
+      def insert
+        params = { calendarId: Calendar.id }
+        body   = self.to_json
+        request(Calendar.api.events.insert, params, body)
+      end
+
+      def self.insert(options={})
+        self.new(options).insert
+      end
+
+      # [API] delete
+      #   DELETE /calendars/:calendarId/events/:eventId
+      def delete
+        params  = { calendarId: Calendar.id, eventId: id }
+        request(Calendar.api.events.delete, params)
+        self
+      end
+
+      def self.delete(id)
+        self.new(id: id).fetch.delete
+      end
+
+      # [API] quickAdd
+      #   POST /calendars/:calendarId/events/quickAdd
+      def self.quickAdd(text)
+        params = { calendarId: Calendar.id, text: text }
+        request(Calendar.api.events.quick_add, params)
+      end
+
+      # [API] update
+      #   PUT /calendars/:calendarId/events/:eventId
+      def update
+        params = { calendarId: Calendar.id, eventId: id }
+        body = self.to_json
+        request(Calendar.api.events.update, params, body)
+        self
+      end
+
+      def to_hash
+        self.instance_variables.inject(Hashie::Mash.new) do |hash, name|
+          key = name.to_s.delete("@").to_sym
+          hash[key] = self.instance_variable_get(name)
+          hash
+        end
+      end
+
+      def to_json
+        self.to_hash.to_json
+      end
+
+      def num_of_days
+        start_date = (self.start.date || self.start.dateTime).to_date
+        end_date   = (self.end.date   || self.end.dateTime  ).to_date
+        (end_date - start_date).to_i + 1
+      end
+
+      def self.today
+        start_time = Date.today
+        end_time   = Date.tomorrow
+        list(start_time, end_time)
+      end
+
+      def self.tomorrow
+        start_time = Date.tomorrow
+        end_time   = Date.tomorrow.tomorrow
+        list(start_time, end_time)
+      end
+
+      def self.yesterday
+        start_time = Date.yesterday
+        end_time   = Date.today
+        list(start_time, end_time)
+      end
+
+      def self.this_week
+        start_time = Date.today.beginning_of_week
+        end_time   = Date.today.end_of_week
+        list(start_time, end_time)
+      end
+
+      def self.this_month
+        start_time = Date.today.beginning_of_month
+        end_time   = Date.today.end_of_month
+        list(start_time, end_time)
+      end
+
+      def self.this_year
+        start_time = Date.today.beginning_of_year
+        end_time   = Date.today.end_of_year
+        list(start_time, end_time)
+      end
+
+      private
+
+      def update_attributes(options={})
+        opts = Hashie::Mash.new(options)
+        opts.each do |key, value|
+          instance_variable_set("@#{key}".to_sym, value) if respond_to?(key)
+        end
+      end
+
+      def request(api_method, params={}, body="")
+        data = self.class.execute(api_method, params, body)
+        if data.respond_to?(:to_hash)
+          update_attributes(data.to_hash)
+        elsif data.nil?
+          {}
+        else
+          raise data.to_s
+        end
+        self
+      end
+
+      def self.request(api_method, params={}, body="")
+        data = execute(api_method, params, body)
+        if data.respond_to?(:items)
+          data_to_events(data.items)
+        elsif data.respond_to?(:to_hash)
+          data_to_event(data)
+        else
+          raise data.to_s
+        end
+      end
+
+      def self.execute(api_method, params={}, body="")
+        response = Calendar.execute(api_method, params, body)
+        response.data
+      end
+      
+      def self.data_to_event(event_data)
+        self.new(event_data.to_hash)
+      end
+
+      def self.data_to_events(events_data)
+        events_data.inject([]) do |events, event_data|
+          events << data_to_event(event_data)
+        end
+      end
+    end
+  end
+end

data/lib/google/service_account.rb

@@ -0,0 +1,31 @@
+module Google
+  class ServiceAccount
+    CLIENT_ID_SUFFIX             = ".apps.googleusercontent.com"
+    CLIENT_EMAIL_DOMAIN          = "developer.gserviceaccount.com"
+    ACCOUNTS_GOOGLE_COM_BASE_URI = "https://accounts.google.com"
+    WWW_GOOGLEAPIS_COM_BASE_URI  = "https://www.googleapis.com"
+  
+    attr_reader :id
+    attr_reader :auth_uri, :token_uri
+    attr_reader :client_id, :client_email
+    attr_reader :auth_provider_x509_cert_url, :client_x509_cert_url
+    attr_reader :scope
+
+    def initialize(client_id)
+      @id = client_id.include?(CLIENT_ID_SUFFIX) ? scan_id(client_id) : client_id
+      @auth_uri                    = ACCOUNTS_GOOGLE_COM_BASE_URI + "/o/oauth2/auth"
+      @token_uri                   = ACCOUNTS_GOOGLE_COM_BASE_URI + "/o/oauth2/token"
+      @client_id                   = @id + CLIENT_ID_SUFFIX
+      @client_email                = @id + "@" + CLIENT_EMAIL_DOMAIN
+      @auth_provider_x509_cert_url = WWW_GOOGLEAPIS_COM_BASE_URI  + "/oauth2/v1/certs"
+      @client_x509_cert_url        = WWW_GOOGLEAPIS_COM_BASE_URI  + "/robot/v1/metadata/x509" + @client_email
+      @scope                       = WWW_GOOGLEAPIS_COM_BASE_URI  + "/auth/calendar"
+    end
+
+    private
+
+    def scan_id(client_id)
+      client_id.scan(/^(.*)#{CLIENT_ID_SUFFIX}$/).first.first
+    end
+  end
+end

data/spec/google/calendar/event_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+require 'pry'
+
+describe Google::Calendar::Event do
+
+  let(:event_instance_variables) { [ :id, :kind, :etag, :status, :htmlLink, :created, :updated, 
+                                     :creator, :organizer, :transparency, :iCalUID, :sequence, :reminders,
+                                     :summary, :start, :end ] }
+  let(:calendar_id) { "aaaaaaaaaaaaaaaaaaaaaaaaaa@group.calendar.google.com" }
+  let(:client_id)   { "1000000000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.apps.googleusercontent.com" }
+  let(:client_execute_options) { { api_method:  api_method,
+                                   parameters:  parameters,
+                                   body:        body,
+                                   headers:     { 'Content-Type' => 'application/json' } } }
+  let(:test_data)  { { kind:         "calendar#event",
+                       etag:         "\"1000000000000000\"",
+                       id:           id,
+                       status:       "confirmed",
+                       htmlLink:     "https://www.google.com/calendar/event?eid=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                       created:      "2015-07-07T00:00:00.000Z",
+                       updated:      "2015-07-07T01:00:00.000Z",
+                       summary:      summary,
+                       creator:      { email: "testuser@gmail.com", displayName: "testuser" },
+                       organizer:    { email: calendar_id,  displayName: "testcalendar", self: true },
+                       start:        start_date,
+                       end:          end_date,
+                       transparency: "transparent",
+                       iCalUID:      id + "@google.com",
+                       sequence:     0,
+                       reminders:    { useDefault: true } } }
+  let(:id) { "aaaaaaaaaaaaaaaaaaaaaaaaaa" }
+  let(:summary)    { "Test Event" }
+  let(:start_date) { { date: Date.today } }
+  let(:end_date)   { { date: Date.tomorrow } }
+
+  before do
+    allow(Google::APIClient::KeyUtils).to receive(:load_key) { OpenSSL::PKey::RSA.new }
+    allow(File).to receive(:exist?) { true }
+    allow_any_instance_of(Signet::OAuth2::Client).to receive(:fetch_access_token!) { true }
+    Google::Calendar.client_id = client_id
+    Google::Calendar.id = calendar_id
+    allow(Google::Calendar).to receive(:authorize?) { true }
+  end
+
+  describe '#initialize' do
+    context 'without otpion' do
+      it 'should be instance of Google::Calendar::Event' do
+        event = Google::Calendar::Event.new
+        expect(event).to be_instance_of Google::Calendar::Event
+        event_instance_variables.each{|name| expect(event.send(name)).to be_nil }
+      end
+    end
+
+    context 'with all otpion' do
+      let(:options) { { summary: summary, start: { date: Date.today }, end: { date: Date.tomorrow } } }
+
+      it 'should be instance of Google::Calendar::Event' do
+        event = Google::Calendar::Event.new(options)
+        expect(event).to be_instance_of Google::Calendar::Event
+        event_instance_variables.each do |name|
+          case name
+          when :summary
+            expect(event.send(name)).to eq options[name]
+          when :start, :end
+            expect(event.send(name).date).to eq options[name][:date]
+          else
+            expect(event.send(name)).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  # [API] get
+  #   GET /calendars/:calendarId/events/eventId
+  describe 'GET /calendars/:calendarId/events/eventId' do
+    let(:event)      { Google::Calendar::Event.new(options) }
+    let(:options)    { { id: id, summary: summary, start: start_date, end: end_date } }
+
+    let(:api_method) { Google::Calendar.api.events.get }
+    let(:parameters) { { calendarId: calendar_id, eventId: id } }
+    let(:body)       { "" }
+
+    let(:response)   { Hashie::Mash.new( { status: status, data: data } ) } 
+    let(:status)     { 200 }
+    let(:data)       { test_data }
+
+    before do
+      expect_any_instance_of(Google::APIClient).to receive(:execute!).with(client_execute_options) { response }
+    end
+
+    describe '.get' do
+      it 'should be instance of Google::Calendar::Event' do
+        event = Google::Calendar::Event.get(id)
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+
+    describe '#fetch' do
+      it 'should be instance of Google::Calendar::Event' do
+        event.fetch
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+  end
+
+  # [API] list
+  #   GET /calendars/:calendarId/events
+  describe 'GET /calendars/:calendarId/events' do
+    let(:api_method) { Google::Calendar.api.events.list }
+    let(:parameters) { { calendarId: calendar_id,
+                         orderBy:    'startTime',
+                         timeMax:    end_time.to_time.utc.iso8601,
+                         timeMin:    start_time.to_time.utc.iso8601,
+                         singleEvents: 'True' } }
+    let(:body)       { "" }
+
+    let(:response)   { Hashie::Mash.new( { status: status, data: data } ) }
+    let(:status)     { 200 }
+    let(:data)       { { items: [ test_data ] } }
+
+    let(:start_time) { Date.today.beginning_of_week }
+    let(:end_time)   { Date.today.end_of_week }
+
+    describe '.list' do
+      before do
+        expect_any_instance_of(Google::APIClient).to receive(:execute!).with(client_execute_options) { response }
+      end
+
+      it 'should be instance of Google::Calendar::Event' do
+        events = Google::Calendar::Event.list(start_time, end_time)
+        expect(events.size).to eq 1
+        event = events.first
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+
+    shared_examples 'Called Event.list and Recieve Start and End' do
+      before { expect(Google::Calendar::Event).to receive(:list).with(start_time, end_time) }
+      it { is_expected.not_to raise_error }
+    end
+
+    describe '.today' do
+      let(:start_time) { Date.today }
+      let(:end_time)   { Date.tomorrow }
+      subject { lambda { Google::Calendar::Event.today } }
+      it_behaves_like 'Called Event.list and Recieve Start and End'
+    end
+
+    describe '.tomorrow' do
+      let(:start_time) { Date.tomorrow }
+      let(:end_time)   { Date.tomorrow.tomorrow }
+      subject { lambda { Google::Calendar::Event.tomorrow } }
+      it_behaves_like 'Called Event.list and Recieve Start and End'
+    end
+
+    describe '.yesterday' do
+      let(:start_time) { Date.yesterday }
+      let(:end_time)   { Date.today }
+      subject { lambda { Google::Calendar::Event.yesterday } }
+      it_behaves_like 'Called Event.list and Recieve Start and End'
+    end
+
+    describe '.this_week' do
+      let(:start_time) { Date.today.beginning_of_week }
+      let(:end_time)   { Date.today.end_of_week }
+      subject { lambda { Google::Calendar::Event.this_week } }
+      it_behaves_like 'Called Event.list and Recieve Start and End'
+    end
+
+    describe '.this_month' do
+      let(:start_time) { Date.today.beginning_of_month }
+      let(:end_time)   { Date.today.end_of_month }
+      subject { lambda { Google::Calendar::Event.this_month } }
+      it_behaves_like 'Called Event.list and Recieve Start and End'
+    end
+
+    describe '.this_year' do
+      let(:start_time) { Date.today.beginning_of_year }
+      let(:end_time)   { Date.today.end_of_year }
+      subject { lambda { Google::Calendar::Event.this_year } }
+      it_behaves_like 'Called Event.list and Recieve Start and End'
+    end
+  end
+
+  # [API] insert
+  #   POST /calendars/:calendarId/events
+  describe 'POST /calendars/:calendarId/events' do
+    let(:event)      { Google::Calendar::Event.new(options) }
+    let(:options)    { { summary: summary, start: start_date, end: end_date } }
+
+    let(:api_method) { Google::Calendar.api.events.insert }
+    let(:parameters) { { calendarId: calendar_id } }
+    let(:body)       { event.to_json }
+
+    let(:response)   { Hashie::Mash.new( { status: status, data: test_data } ) } 
+    let(:status)     { 200 }
+    let(:data)       { test_data }
+
+    before do
+      expect_any_instance_of(Google::APIClient).to receive(:execute!).with(client_execute_options) { response }
+    end
+
+    describe '#insert' do
+      it 'should be instance of Google::Calendar::Event' do
+        event.insert
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+
+    describe '.insert' do
+      it 'should be instance of Google::Calendar::Event' do
+        event = Google::Calendar::Event.insert(options)
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+  end
+
+  # [API] delete
+  #   DELETE /calendars/:calendarId/events/:eventId
+  describe 'DELETE /calendars/:calendarId/events/:eventId' do
+    let(:event)      { Google::Calendar::Event.new(options) }
+    let(:options)    { { id: id, summary: summary, start: start_date, end: end_date } }
+
+    let(:api_method) { Google::Calendar.api.events.delete }
+    let(:parameters) { { calendarId: calendar_id, eventId: id } }
+    let(:body)       { "" }
+
+    let(:response)   { Hashie::Mash.new( { status: status, data: test_data } ) } 
+    let(:status)     { 204 }
+    let(:data)       { nil }
+
+    before do
+      allow_any_instance_of(Google::Calendar::Event).to receive(:fetch) { event }
+      expect_any_instance_of(Google::APIClient).to receive(:execute!).with(client_execute_options) { response }
+    end
+
+    describe '#delete' do
+      it 'should be instance of Google::Calendar::Event' do
+        event.delete
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+
+    describe '.delete' do
+      it 'should be instance of Google::Calendar::Event' do
+        event = Google::Calendar::Event.delete(id)
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+  end
+
+  # [API] quickAdd
+  #   POST /calendars/:calendarId/events/quickAdd
+  describe 'POST /calendars/:calendarId/events/quickAdd' do
+    let(:event)      { Google::Calendar::Event.new(options) }
+    let(:options)    { { summary: summary, start: start_date, end: end_date } }
+
+    let(:api_method) { Google::Calendar.api.events.quick_add }
+    let(:parameters) { { calendarId: calendar_id, text: summary } }
+    let(:body)       { "" }
+
+    let(:response)   { Hashie::Mash.new( { status: status, data: test_data } ) } 
+    let(:status)     { 200 }
+    let(:data)       { test_data }
+
+    before do
+      expect_any_instance_of(Google::APIClient).to receive(:execute!).with(client_execute_options) { response }
+    end
+
+    describe '#quickAdd' do
+      it 'should be instance of Google::Calendar::Event' do
+        event = Google::Calendar::Event.quickAdd(summary)
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+  end
+
+  # [API] update
+  #   PUT /calendars/:calendarId/events/:eventId
+  describe 'PUT /calendars/:calendarId/events/:eventId' do
+    let(:event)      { Google::Calendar::Event.new(options) }
+    let(:options)    { { id: id, summary: summary, start: start_date, end: end_date } }
+
+    let(:api_method) { Google::Calendar.api.events.update }
+    let(:parameters) { { calendarId: calendar_id, eventId: id } }
+    let(:body)       { event.to_json }
+
+    let(:response)   { Hashie::Mash.new( { status: status, data: test_data } ) } 
+    let(:status)     { 200 }
+    let(:data)       { test_data }
+
+    before do
+      expect_any_instance_of(Google::APIClient).to receive(:execute!).with(client_execute_options) { response }
+    end
+
+    describe '#update' do
+      it 'should be instance of Google::Calendar::Event' do
+        event.update
+        expect(event.summary).to eq summary
+        expect(event).to be_instance_of Google::Calendar::Event
+        expect_event_to_eq_test_data(event, test_data)
+      end
+    end
+  end
+
+  describe '#num_of_days' do
+    let(:event)      { Google::Calendar::Event.new(options) }
+    let(:options)    { { summary: summary, start: start_date, end: end_date } }
+
+    # num_of_days : today ~ tomorrow
+    subject { event.num_of_days }
+    it { is_expected.to eq 2 }
+  end
+
+  def expect_event_to_eq_test_data(event, test_data)
+    test_data.each_key do |key|
+      case key
+      when :creator, :organizer
+       expect(event.send(key).email).to       eq test_data[key][:email]
+        expect(event.send(key).displayName).to eq test_data[key][:displayName]
+        expect(event.send(key).self).to        eq test_data[key][:self] if key == :organizer
+      when :start, :end
+        expect(event.send(key).date).to        eq test_data[key][:date]
+      when :reminders
+        expect(event.send(key).useDefault).to  eq test_data[key][:useDefault]
+      else
+        expect(event.send(key)).to             eq test_data[key]
+      end
+    end
+  end
+end

data/spec/google/calendar_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Google::Calendar do
+  let(:id)        { "aaaaaaaaaaaaaaaaaaaaaaaaaa@group.calendar.google.com" }
+  let(:client_id) { "1000000000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.apps.googleusercontent.com" }
+  let(:event_id)  { "aaaaaaaaaaaaaaaaaaaaaaaaaa" }
+
+  before do
+    allow(Google::APIClient::KeyUtils).to receive(:load_key) { OpenSSL::PKey::RSA.new }
+    allow(File).to receive(:exist?) { true }
+    allow_any_instance_of(Signet::OAuth2::Client).to receive(:fetch_access_token!) { true }
+    Google::Calendar.client_id = client_id
+  end
+
+  describe '.api' do
+    before { allow(Google::Calendar).to receive(:authorized?) { true } }
+    subject { Google::Calendar.api }
+    it { is_expected.to be_instance_of Google::APIClient::API }
+  end
+
+  describe '.client' do
+    subject { Google::Calendar.client }
+    it { is_expected.to be_instance_of Google::APIClient }
+  end
+
+  describe '.authorize' do
+    subject { Google::Calendar.authorize }
+    it { is_expected.to eq true }
+  end
+
+  describe '.secret_key' do
+    subject { Google::Calendar.secret_key }
+    it { is_expected.to be_instance_of Google::SecretKey }
+  end
+
+  describe '.service_account' do
+    subject { Google::Calendar.service_account }
+    it { is_expected.to be_instance_of Google::ServiceAccount }
+  end
+
+  describe '.singing_key' do
+    subject { Google::Calendar.signing_key }
+    it { is_expected.to be_instance_of OpenSSL::PKey::RSA }
+  end
+
+  describe 'authorized?' do
+    subject { Google::Calendar.authorized? }
+
+    context 'authorized instance is false or nil' do
+      before { Google::Calendar.instance_variable_set(:@authorized, false) }
+      it { is_expected.to eq false }
+    end
+
+    context 'authorized instance is true' do
+      before { Google::Calendar.instance_variable_set(:@authorized, true) }
+      it { is_expected.to eq true }
+    end
+  end
+
+  describe 'execute' do
+    let(:method)     { Google::Calendar.api.events.get.class }
+    let(:parameters) { { calendarId: id, eventId: event_id } }
+    let(:body)       { "" }
+    let(:options)    { { api_method: method,
+                         parameters: parameters,
+                         body: body,
+                         headers: { 'Content-Type' => 'application/json' } } }
+
+    before do
+      expect_any_instance_of(Google::APIClient).to receive(:execute!).with(options) { true }
+      allow(Google::Calendar).to receive(:authorize?) { true }
+    end
+
+    subject { Google::Calendar.execute(method, parameters, body) }
+    it { is_expected.to eq true }
+  end
+end

data/spec/google/service_account_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Google::ServiceAccount do
+  let(:client_id_suffix)             { ".apps.googleusercontent.com" }
+  let(:client_email_domain)          { "developer.gserviceaccount.com" } 
+  let(:accounts_google_com_base_uri) { "https://accounts.google.com" }
+  let(:www_googleapis_com_base_uri)  { "https://www.googleapis.com" }
+
+  let(:id)                           { "1000000000000-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }
+  let(:client_id)                    { id + ".apps.googleusercontent.com" }
+  let(:auth_uri)                     { accounts_google_com_base_uri + "/o/oauth2/auth" }
+  let(:token_uri)                    { accounts_google_com_base_uri + "/o/oauth2/token" }
+  let(:client_email)                 { id + "@" + client_email_domain }
+  let(:auth_provider_x509_cert_url)  { www_googleapis_com_base_uri + "/oauth2/v1/certs" }
+  let(:client_x509_cert_url)         { www_googleapis_com_base_uri + "/robot/v1/metadata/x509" + client_email }
+  let(:scope)                        { www_googleapis_com_base_uri + "/auth/calendar" }
+
+
+  describe '::CLIENT_ID_SUFFIX' do
+    subject { Google::ServiceAccount::CLIENT_ID_SUFFIX }
+    it { is_expected.to eq client_id_suffix }
+  end
+
+  describe '::CLIENT_EMAIL_DOMAIN' do
+    subject { Google::ServiceAccount::CLIENT_EMAIL_DOMAIN }
+    it { is_expected.to eq client_email_domain }
+  end
+
+  describe '::ACCOUNTS_GOOGLE_COM_BASE_URI' do
+    subject { Google::ServiceAccount::ACCOUNTS_GOOGLE_COM_BASE_URI }
+    it { is_expected.to eq accounts_google_com_base_uri }
+  end
+
+  describe '::WWW_GOOGLEAPIS_COM_BASE_URI' do
+    subject { Google::ServiceAccount::WWW_GOOGLEAPIS_COM_BASE_URI }
+    it { is_expected.to eq www_googleapis_com_base_uri }
+  end
+
+  describe '#initialize' do
+    it 'should be instance of Google::ServiceAccount' do
+     service_account = Google::ServiceAccount.new(client_id)
+     expect(service_account.id).to eq id
+     expect(service_account.auth_uri).to eq auth_uri
+     expect(service_account.token_uri).to eq token_uri
+     expect(service_account.client_id).to eq client_id
+     expect(service_account.client_email).to eq client_email
+     expect(service_account.auth_provider_x509_cert_url).to eq auth_provider_x509_cert_url
+     expect(service_account.client_x509_cert_url).to eq client_x509_cert_url
+     expect(service_account.scope).to eq scope
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter '.bundle/'
+  add_filter '/spec/'
+end
+
+require 'gcevent'

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: gcevent
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ogawatti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- ogawattim@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gcevent.gemspec
+- lib/gcevent.rb
+- lib/google/calendar.rb
+- lib/google/calendar/errors.rb
+- lib/google/calendar/event.rb
+- lib/google/service_account.rb
+- spec/google/calendar/event_spec.rb
+- spec/google/calendar_spec.rb
+- spec/google/service_account_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ogawatti/gcevent
+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.4.8
+signing_key: 
+specification_version: 4
+summary: A wrapper of Google Calendar Event API.
+test_files:
+- spec/google/calendar/event_spec.rb
+- spec/google/calendar_spec.rb
+- spec/google/service_account_spec.rb
+- spec/spec_helper.rb