fog-wunderlist 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9eab9e1e8ed0e83e454f35ee0f16dd96f2c1e658
+  data.tar.gz: cfb8e204a8967762f1d206ca2ebb277804abbd5d
+SHA512:
+  metadata.gz: 480e90e5115d6c5131cc0400649cb718fe58e7032d390b4f1cc85760cb033fb35d6007fdd8639fa3efef84d348cfb39fadfad06d5afb3b89715907753406981c
+  data.tar.gz: c8d423ca38b576f7ca4562e4ad07fd068fd1ffda7ab1d183b391d1fe2fc6056a481a3415056465f1218371da8574cc066ef82cb9dfc714be1dcebd9702b5d169

data/.gitignore

@@ -0,0 +1,3 @@
+tests/.fog
+Gemfile.lock
+pkg/*

data/CONTRIBUTING.md

@@ -0,0 +1,25 @@
+# Contributing
+
+The structure of the library is pretty similar to any Fog provider with the
+exception that a new 'Tasks' service has been added. Same Fog rules for 
+contributing apply.
+
+## Building the gem
+
+```
+bundle install
+rake build
+```
+
+## Testing fog-wunderlist
+
+Create a tests/.fog file with your Wunderlist credentials:
+
+```
+# tests/.fog content
+:default:
+  :wunderlist_username: myemail@foobar.com
+  :wunderlist_password: secret
+```
+
+Then run [shindo](http://github.com/shindo).

data/Gemfile

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

data/LICENSE.md

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2013 [rubiojr (Sergio Rubio)](http://github.com/rubiojr)
+
+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,113 @@
+# Wunderlist Fog provider
+
+Fog provider to manage www.wunderlist.com tasks using the familiar
+[Fog](http://fog.io) interface.
+
+The provider is fully functional an only depends on Fog. Note that
+Wunderlist does not provide a public API so the API might change at
+any time breaking this library.
+
+fog-wunderlist is based on the excellent work from 
+https://github.com/bsmt/wunderpy and some API request sniffing
+done by myself.
+
+## Installation
+
+    gem install fog-wunderlist
+
+## Connecting to Wunderlist
+
+```ruby
+
+require 'fog/wunderlist'
+require 'pp'
+
+service = Fog::Tasks.new :provider => 'Wunderlist',
+                         :wunderlist_username => 'myemail@foo.com',
+                         :wunderlist_password => 'secret'
+
+```
+
+## Managing tasks
+
+```ruby
+
+# Listing tasks
+service.tasks.each do |task|
+  pp task # => 
+  # <Fog::Tasks::Wunderlist::Task
+  #   id="ACQSAACGzsM",
+  #   recurrence_count=0,
+  #   assignee_id=nil,
+  #   user_id="AAQSAAAHQGM",
+  #   title="Tap to open me",
+  #   recurring_parent_id=nil,
+  #   note="",
+  #   parent_id=nil,
+  #   version=5,
+  #   list_id="inbox",
+  #   type="Task",
+  #   owner_id="AAQSAAAHQGM",
+  #   created_by_id=nil,
+  #   due_date=nil,
+  #   created_at=2012-12-06 14:32:31 UTC,
+  #   completed_at=2012-12-06 14:32:31 UTC,
+  #   updated_at=2012-12-06 14:32:31 UTC,
+  #   local_identifier=nil,
+  #   position=0.0,
+  #   starred=true
+  # >
+end
+
+# Creating a new Task in my 'Home' list
+list = service.lists.find { |l| l.title == 'Home' }
+service.tasks.create :title => 'test task',
+                     :starred => true,
+                     :list_id => list.id
+
+# There's a special list named 'inbox' also
+# that is not listed but we can use
+service.tasks.create :title => 'test task',
+                     :starred => true,
+                     :list_id => 'inbox'
+
+# Updating a task
+task = service.tasks.find { |t| t.title == 'my task' } 
+task.note = 'some random notes'
+task.starred = true
+task.save
+
+# Deleting the task
+task.destroy
+```
+
+## Managing lists
+
+```ruby
+# List all the lists (inbox isn't listed)
+service.lists.each do |list|
+  pp list # =>
+  #<Fog::Tasks::Wunderlist::List
+  #  id="ABQSAABVlOE",
+  #  title="Home",
+  #  created_at=2012-12-06 00:09:15 UTC,
+  #  updated_at=2013-03-28 20:53:14 UTC,
+  #  version=2,
+  #  local_identifier=nil,
+  #  position=18.0,
+  #  type="List",
+  #  owner_id="AAQSAAAHQGM"
+  #>
+end
+
+# Creating a new list
+list = service.lists.create :title => 'new list'
+
+# Updating the list
+list.title = 'new title for the list'
+list.save
+
+# Destroy the list
+list.destroy
+
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/TODO.md

@@ -0,0 +1 @@
+* Implement mocking

data/fog-wunderlist.gemspec

@@ -0,0 +1,24 @@
+# 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          = "fog-wunderlist"
+  spec.version       = "0.1"
+  spec.authors       = ["Sergio Rubio"]
+  spec.email         = ["rubiojr@frameos.org"]
+  spec.description   = %q{www.wunderlist.com Fog provider}
+  spec.summary       = %q{www.wunderlist.com Fog provider}
+  spec.homepage      = "https://github.com/rubiojr"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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('fog', '>= 1.0')
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "shindo"
+end

data/lib/fog/tasks.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Tasks
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+
+      if self.providers.include?(provider)
+        require "fog/#{provider}/tasks"
+        return Fog::Tasks.const_get(Fog.providers[provider]).new(attributes)
+      end
+      raise ArgumentError.new("#{provider} is not a recognized tasks provider")
+    end
+
+    def self.providers
+      Fog.services[:tasks]
+    end
+
+    def self.servers
+      servers = []
+      for provider in self.providers
+        begin
+          servers.concat(self[provider].servers)
+        rescue # ignore any missing credentials/etc
+        end
+      end
+      servers
+    end
+
+  end
+end

data/lib/fog/wunderlist.rb

@@ -0,0 +1,10 @@
+require 'fog/core'
+require 'fog/tasks'
+
+module Fog
+  module Wunderlist 
+    extend Fog::Provider
+    service(:tasks, 'wunderlist/tasks', 'Tasks')
+  end
+end
+

data/lib/fog/wunderlist/models/tasks/list.rb

@@ -0,0 +1,47 @@
+require 'fog/core/model'
+
+module Fog
+  module Tasks
+    class Wunderlist 
+      class List < Fog::Model
+        
+        identity  :id
+
+        attribute :title
+        attribute :created_at,       :type => :time
+        attribute :updated_at,       :type => :time
+        attribute :version
+        attribute :local_identifier
+        attribute :position
+        attribute :type
+        attribute :owner_id
+        
+        def destroy
+          requires :id
+          service.delete_list(id)
+          true
+        end
+
+        def save
+          requires :title
+          if identity
+            update
+          else
+            merge_attributes(
+              service.create_list(title, attributes).body
+            )
+          end
+          true
+        end
+
+        def update
+          requires :id
+          merge_attributes(
+            service.update_list(id, attributes).body
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/models/tasks/lists.rb

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/wunderlist/models/tasks/list'
+
+module Fog
+  module Tasks 
+    class Wunderlist
+
+      class Lists < Fog::Collection
+        model Fog::Tasks::Wunderlist::List
+
+        def all
+          load service.list_lists.body
+        end
+
+        def get(id)
+          all.find{ |l| l.id == id}
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/wunderlist/models/tasks/task.rb

@@ -0,0 +1,59 @@
+require 'fog/core/model'
+
+module Fog
+  module Tasks
+    class Wunderlist 
+      class Task < Fog::Model
+        
+        identity  :id
+
+        attribute :recurrence_count,      :type => :integer
+        attribute :assignee_id
+        attribute :user_id
+        attribute :title
+        attribute :recurring_parent_id
+        attribute :note
+        attribute :parent_id
+        attribute :version,               :type => :integer
+        attribute :list_id
+        attribute :type
+        attribute :owner_id
+        attribute :created_by_id
+        attribute :due_date,              :type => :time
+        attribute :created_at,            :type => :time
+        attribute :completed_at,          :type => :time
+        attribute :updated_at,            :type => :time
+        attribute :local_identifier
+        attribute :position,              :type => :float
+        attribute :starred,               :type => :boolean
+
+        def destroy
+          requires :id
+          service.delete_task(id)
+          true
+        end
+
+        def save
+          requires :list_id, :title
+          if identity
+            update
+          else
+            merge_attributes(
+              service.create_task(title, list_id, attributes).body
+            )
+          end
+          true
+        end
+
+        def update
+          requires :id
+          merge_attributes(
+            service.update_task(id, attributes).body
+          )
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/models/tasks/tasks.rb

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/wunderlist/models/tasks/task'
+
+module Fog
+  module Tasks 
+    class Wunderlist
+
+      class Tasks < Fog::Collection
+        model Fog::Tasks::Wunderlist::Task
+
+        def all
+          load service.list_tasks.body
+        end
+
+        def get(id)
+          all.find { |t| t.id == id }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/create_list.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def create_list(title, attributes = {})
+          request(
+            :expects  => [201],
+            :method   => 'POST',
+            :path     => "/me/lists",
+            :body     => { :title => title }.merge(attributes)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_list(title, attributes = {})
+          Fog::Mock.not_implemented
+          #response = Excon::Response.new
+          #response.status = 200
+          #response.body = {
+          #}
+          #response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/create_task.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def create_task(title, list_id, attributes = {})
+          request(
+            :expects  => [201],
+            :method   => 'POST',
+            :path     => "/me/tasks",
+            :body     => { 
+              :title => title,
+              :list_id => list_id
+            }.merge(attributes)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_task(attributes)
+          Fog::Mock.not_implemented
+          #response = Excon::Response.new
+          #response.status = 200
+          #response.body = {
+          #}
+          #response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/delete_list.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def delete_list(id)
+          request(
+            :expects  => [200],
+            :method   => 'DELETE',
+            :path     => "/#{id}"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_list(id)
+          Fog::Mock.not_implemented
+          #response = Excon::Response.new
+          #response.status = 200
+          #response.body = {
+          #}
+          #response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/delete_task.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def delete_task(id)
+          request(
+            :expects  => [200],
+            :method   => 'DELETE',
+            :path     => "/#{id}"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_task(id)
+          Fog::Mock.not_implemented
+          #response = Excon::Response.new
+          #response.status = 200
+          #response.body = {
+          #}
+          #response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/get_task.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def get_task(id)
+          request(
+            :expects  => [200],
+            :method   => 'GET',
+            :path     => "/me/#{id}"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def get_tasks(id)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/list_lists.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def list_lists
+          request(
+            :expects  => [200],
+            :method   => 'GET',
+            :path     => '/me/lists'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def list_lists
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/list_tasks.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def list_tasks
+          request(
+            :expects  => [200],
+            :method   => 'GET',
+            :path     => '/me/tasks'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def list_tasks
+          Fog::Mock.not_implementeD
+          #response = Excon::Response.new
+          #response.status = 200
+          #response.body = {
+          #}
+          #response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/update_list.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def update_list(id, attributes = {})
+          request(
+            :expects  => [200],
+            :method   => 'PUT',
+            :path     => "#{id}",
+            :body     => attributes 
+          )
+        end
+
+      end
+
+      class Mock
+
+        def update_list(id, attributes = {})
+          Fog::Mock.not_implemented
+          #response = Excon::Response.new
+          #response.status = 200
+          #response.body = {
+          #}
+          #response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/requests/tasks/update_task.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Tasks 
+    class Wunderlist 
+      class Real
+
+        def update_task(id, attributes = {})
+          request(
+            :expects  => [200],
+            :method   => 'PUT',
+            :path     => "#{id}",
+            :body     => attributes 
+          )
+        end
+
+      end
+
+      class Mock
+
+        def update_task(id, attributes = {})
+          Fog::Mock.not_implemented
+          #response = Excon::Response.new
+          #response.status = 200
+          #response.body = {
+          #}
+          #response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/tasks.rb

@@ -0,0 +1,107 @@
+require 'fog/wunderlist'
+require 'fog/tasks'
+
+module Fog
+  module Tasks
+    class Wunderlist < Fog::Service
+
+      requires     :wunderlist_username
+      requires     :wunderlist_password
+
+      recognizes   :wunderlist_api_url
+
+      model_path   'fog/wunderlist/models/tasks'
+      model        :task
+      collection   :tasks
+      model        :list
+      collection   :lists
+      
+      request_path 'fog/wunderlist/requests/tasks'
+      request      :list_tasks
+      request      :list_lists
+      request      :create_task
+      request      :delete_task
+      request      :update_task
+      request      :create_list
+      request      :delete_list
+      request      :update_list
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :tasks => [],
+              :lists => []
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @password = options[:wunderlist_password]
+        end
+
+        def data
+          self.class.data[@password]
+        end
+
+        def reset_data
+          self.class.data.delete(@password)
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          @username   = options[:wunderlist_username]
+          @password   = options[:wunderlist_password]
+          @api_url    = options[:wunderlist_api_url] || 'https://api.wunderlist.com'
+          @connection = Fog::Connection.new(@api_url)
+          @auth_data  = authenticate
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params = {})
+          params.merge!(
+            :headers => { 
+              'Authorization' => "Bearer #{@auth_data['token']}",
+              'Content-Type'  => 'application/json; charset=utf-8'
+            },
+            :body => Fog::JSON.encode(params[:body])
+          )
+          response = @connection.request(params)
+
+          unless response.body.empty?
+            response.body = Fog::JSON.decode(response.body)
+            #if response.body['status'] != 'OK'
+            #  raise Fog::Errors::Error.new
+            #end
+          end
+          response
+        end
+        
+        private
+        def authenticate
+          res = @connection.request :method  => 'POST', 
+                                    :path    => '/login',
+                                    :expects => [200],
+                                    :body    => Fog::JSON.encode({ 
+                                      :email => @username, 
+                                      :password => @password
+                                    })
+          Fog::JSON.decode(res.body)
+        end
+
+
+      end
+    end
+  end
+end

data/lib/fog/wunderlist/version.rb

@@ -0,0 +1 @@
+F

data/tests/helper.rb

@@ -0,0 +1,8 @@
+ENV['FOG_RC']         = ENV['FOG_RC'] || File.expand_path('../.fog', __FILE__)
+ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
+
+require 'fog/wunderlist'
+
+Dir["./#{File.dirname(__FILE__)}/helpers/*.rb"].each do |h|
+  require h
+end

data/tests/helpers/format_helpers.rb

@@ -0,0 +1,99 @@
+require "fog/schema/data_validator"
+
+# format related hackery
+# allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
+# allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String)
+module Fog
+  module Boolean; end
+  module Nullable
+    module Boolean; end
+    module Integer; end
+    module String; end
+    module Time; end
+    module Float; end
+    module Hash; end
+    module Array; end
+  end
+end
+[FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)}
+[FalseClass, TrueClass, NilClass, Fog::Boolean].each {|klass| klass.send(:include, Fog::Nullable::Boolean)}
+[NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)}
+[NilClass, Time].each {|klass| klass.send(:include, Fog::Nullable::Time)}
+[Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)}
+[Float, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Float)}
+[Hash, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Hash)}
+[Array, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Array)}
+
+module Shindo
+  class Tests
+
+    # Generates a Shindo test that compares a hash schema to the result
+    # of the passed in block returning true if they match.
+    #
+    # The schema that is passed in is a Hash or Array of hashes that
+    # have Classes in place of values. When checking the schema the
+    # value should match the Class.
+    #
+    # Strict mode will fail if the data has additional keys. Setting
+    # +strict+ to +false+ will allow additional keys to appear.
+    #
+    # @param [Hash] schema A Hash schema
+    # @param [Hash] options Options to change validation rules
+    # @option options [Boolean] :allow_extra_keys
+    #     If +true+ does not fail when keys are in the data that are
+    #     not specified in the schema. This allows new values to
+    #     appear in API output without breaking the check.
+    # @option options [Boolean] :allow_optional_rules
+    #     If +true+ does not fail if extra keys are in the schema
+    #     that do not match the data. Not recommended!
+    # @yield Data to check with schema
+    #
+    # @example Using in a test
+    #     Shindo.tests("comparing welcome data against schema") do
+    #       data = {:welcome => "Hello" }
+    #       data_matches_schema(:welcome => String) { data }
+    #     end
+    #
+    #     comparing welcome data against schema
+    #     + data matches schema
+    #
+    # @example Example schema
+    #     {
+    #       "id" => String,
+    #       "ram" => Integer,
+    #       "disks" => [
+    #         {
+    #           "size" => Float
+    #         }
+    #       ],
+    #       "dns_name" => Fog::Nullable::String,
+    #       "active" => Fog::Boolean,
+    #       "created" => DateTime
+    #     }
+    #
+    # @return [Boolean]
+    def data_matches_schema(schema, options = {})
+      test('data matches schema') do
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, schema, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+
+    # @deprecated #formats is deprecated. Use #data_matches_schema instead
+    def formats(format, strict = true)
+      test('has proper format') do
+        if strict
+          options = {:allow_extra_keys => false, :allow_optional_rules => true}
+        else
+          options = {:allow_extra_keys => true, :allow_optional_rules => true}
+        end
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, format, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+  end
+end

data/tests/helpers/succeeds_helper.rb

@@ -0,0 +1,11 @@
+module Shindo
+  class Tests
+
+    def succeeds
+      test('succeeds') do
+        !!instance_eval(&Proc.new)
+      end
+    end
+
+  end
+end

data/tests/wunderlist/models/list_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests("Fog::Tasks[:wunderlist] | list model") do
+
+  service = Fog::Tasks[:wunderlist]
+
+  tests('success') do
+
+    tests('#save').succeeds do
+      @list = service.lists.new :title => 'fog test list',
+                                :starred => true,
+                                :list_id => 'inbox'
+      @list.save
+    end
+    
+    tests('#update using save').succeeds do
+      @list.title = 'updated title'
+      @list.save
+      service.lists.get(@list.id).title == 'updated title'
+    end
+    
+    tests('#update').succeeds do
+      @list.title = 'updated title 2'
+      @list.update
+      service.lists.get(@list.id).title == 'updated title 2'
+    end
+
+    tests('#destroy').succeeds do
+      @list.destroy
+    end
+  end
+end
+

data/tests/wunderlist/models/task_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests("Fog::Tasks[:wunderlist] | task model") do
+
+  service = Fog::Tasks[:wunderlist]
+
+  tests('success') do
+
+    tests('#save').succeeds do
+      @task = service.tasks.new :title => 'fog test task',
+                                :starred => true,
+                                :list_id => 'inbox'
+      @task.save
+    end
+    
+    tests('#update using save').succeeds do
+      @task.note = 'some note'
+      @task.save
+      service.tasks.get(@task.id).note == 'some note'
+    end
+    
+    tests('#update').succeeds do
+      @task.note = 'some note 2'
+      @task.update
+      service.tasks.get(@task.id).note == 'some note 2'
+    end
+    
+    tests('#destroy').succeeds do
+      @task.destroy
+    end
+  end
+end
+

data/tests/wunderlist/requests/create_task_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Tasks[:wunderlist] | create_task request', ['wunderlist']) do
+  
+  tests('success') do
+
+    test('#create_task') do
+      @task = Fog::Tasks[:wunderlist].create_task("fog test task", 'inbox').body
+      @task['title'] == 'fog test task'
+    end
+
+    test('task list is inbox') do
+      @task['list_id'] == 'inbox'
+    end
+    
+    test('#delete_task') do
+      Fog::Tasks[:wunderlist].delete_task(@task['id']).status == 200
+    end
+  end
+
+  tests('failure') do
+    raises(Excon::Errors::NotFound, '#create_task with invalid list') do
+      Fog::Tasks[:wunderlist].create_task("fog test task", '00000011').body
+    end
+  end
+
+end

data/tests/wunderlist/requests/list_tasks_tests.rb

@@ -0,0 +1,43 @@
+Shindo.tests('Fog::Tasks[:wunderlist] | list_tasks request', ['wunderlist']) do
+  
+  @task_format = {
+    'id'                  => String,
+    'created_at'          => String,
+    'updated_at'          => String,
+    'title'               => String,
+    'starred'             => Fog::Boolean,
+    'note'                => Fog::Nullable::String,
+    'completed_at'        => Fog::Nullable::String,
+    'local_identifier'    => Fog::Nullable::String,
+    'recurrence_type'     => Fog::Nullable::String,
+    'recurrence_count'    => Integer,
+    'recurring_parent_id' => Fog::Nullable::String,
+    'due_date'            => Fog::Nullable::String,
+    'parent_id'           => Fog::Nullable::String,
+    'created_by_id'       => Fog::Nullable::String,
+    'updated_by_id'       => Fog::Nullable::String,
+    'completed_by_id'     => Fog::Nullable::String,
+    'version'             => Integer,
+    'assignee_id'         => Fog::Nullable::String,
+    'type'                => String,
+    'user_id'             => String,
+    'owner_id'            => String,
+    'position'            => Fog::Nullable::Float,
+    'list_id'             => String,
+    'deleted_at'          => Fog::Nullable::String
+  }
+
+  service = Fog::Tasks[:wunderlist]
+  tests('success') do
+    @task = service.create_task("fog test task", 'inbox').body
+    service.list_tasks.body.each do |t| 
+      tests('#list_tasks').formats(@task_format) do
+        t
+      end
+    end
+      
+    service.delete_task @task['id']
+
+  end
+
+end

data/tests/wunderlist/requests/update_list_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Tasks[:wunderlist] | update_list request') do
+  
+  service = Fog::Tasks[:wunderlist]
+
+  tests('success') do
+      
+    tests('#update_list').succeeds do
+      @list = service.lists.create :title => 'test list'
+      service.update_list @list.id, { :title => 'test list modified' }
+      service.lists.get(@list.id).title == 'test list modified'
+    end
+
+    @list.destroy
+
+  end
+
+end

data/tests/wunderlist/requests/update_task_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests('Fog::Tasks[:wunderlist] | create_task request', ['wunderlist']) do
+  
+  service = Fog::Tasks[:wunderlist]
+
+  tests('success') do
+
+    test('#update_task title') do
+      @task = service.create_task("fog test task", 'inbox').body
+      service.update_task @task['id'], { :title => 'updated by fog' }
+      @task = service.tasks.get @task['id']
+      @task.title == 'updated by fog'
+    end
+    
+    test('#update_task note') do
+      service.update_task @task.id, { :note => 'some notes' }
+      @task = service.tasks.get @task.id
+      @task.note == 'some notes'
+    end
+
+    @task.destroy
+  end
+
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: fog-wunderlist
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Sergio Rubio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: shindo
+  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: www.wunderlist.com Fog provider
+email:
+- rubiojr@frameos.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- TODO.md
+- fog-wunderlist.gemspec
+- lib/fog/tasks.rb
+- lib/fog/wunderlist.rb
+- lib/fog/wunderlist/models/tasks/list.rb
+- lib/fog/wunderlist/models/tasks/lists.rb
+- lib/fog/wunderlist/models/tasks/task.rb
+- lib/fog/wunderlist/models/tasks/tasks.rb
+- lib/fog/wunderlist/requests/tasks/create_list.rb
+- lib/fog/wunderlist/requests/tasks/create_task.rb
+- lib/fog/wunderlist/requests/tasks/delete_list.rb
+- lib/fog/wunderlist/requests/tasks/delete_task.rb
+- lib/fog/wunderlist/requests/tasks/get_task.rb
+- lib/fog/wunderlist/requests/tasks/list_lists.rb
+- lib/fog/wunderlist/requests/tasks/list_tasks.rb
+- lib/fog/wunderlist/requests/tasks/update_list.rb
+- lib/fog/wunderlist/requests/tasks/update_task.rb
+- lib/fog/wunderlist/tasks.rb
+- lib/fog/wunderlist/version.rb
+- tests/helper.rb
+- tests/helpers/format_helpers.rb
+- tests/helpers/succeeds_helper.rb
+- tests/wunderlist/models/.list_tests.rb.swp
+- tests/wunderlist/models/list_tests.rb
+- tests/wunderlist/models/task_tests.rb
+- tests/wunderlist/requests/create_task_tests.rb
+- tests/wunderlist/requests/list_tasks_tests.rb
+- tests/wunderlist/requests/update_list_tests.rb
+- tests/wunderlist/requests/update_task_tests.rb
+homepage: https://github.com/rubiojr
+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.0.6
+signing_key: 
+specification_version: 4
+summary: www.wunderlist.com Fog provider
+test_files: []