google-content-api 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7befcf58ddc6c724cdb03706d3f388bf034e9c59
+  data.tar.gz: 2485b540d118c17240864510667805f8d2857e2a
+SHA512:
+  metadata.gz: 158b953cf148e4cb71441067821f0b2eabf523b67983d35bf003fde06937545bb1e14d9b6c4eccd633ec636b96eeabed0edab7ea97ef09800b81b9285c0779e2
+  data.tar.gz: 74dd48bfad2e3da6c4c75a6bd3c307683924b032c064b163f95e118c9f021b35dfc5a4db9443d7cb62a902393fdc7831289362d7282372fcd800b9cb8469a77a

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+config/google_content_api.yml
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--format nested --color

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 DaWanda GmbH
+
+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,44 @@
+# Google Content API
+
+Gem for interacting with [Google's Content API for Shopping](https://developers.google.com/shopping-content/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'google-content-api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install google-content-api
+
+## Example Usage
+
+```ruby
+GoogleContentApi::SubAccount.get_all
+# Get all sub accounts for the user_id specified in conf/google_content_api.yml
+# Note: _must_ be a multi-user google account id
+
+GoogleContentApi::SubAccount.create(title, adult_content, attributes)
+# Create a new subaccount with _title_.
+# Use attributes to include 'description', 'link', 'internal_id',
+# 'reviews_url' or 'adwords_accounts'.
+
+GoogleContentApi::SubAccount.delete(sub_account_id)
+# Deletes a sub account.
+
+GoogleContentApi::Product.create_products(sub_account_id, products, dry_run)
+# Creates products for sub_account_id using batch request. dry_run defaults to false (used for debugging)
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

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

data/config/google_content_api.example

@@ -0,0 +1,10 @@
+client_id: "....apps.googleusercontent.com"
+content_api_scope: "https://www.googleapis.com/auth/structuredcontent"
+client_secret: "..."
+refresh_token: "<refresh token for continuous interactions>"
+redirect_uri: "https://example.com/oauth2callback"
+user_id: "<your user id>"
+application_name: "<your app name>" # Not required
+application_version: "0.0.0" # Not required
+feed_urls:
+  managed_accounts: "https://content.googleapis.com/content/v1/#{USER_ID}/managedaccounts"

data/google-content-api.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'google_content_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "google-content-api"
+  spec.version       = GoogleContentApi::VERSION
+  spec.authors       = ["DaWanda GmbH"]
+  spec.email         = ["amir@dawanda.com"]
+  spec.description   = %q{Gem for interacting with Google's Content API.}
+  spec.summary       = %q{Gem for interacting with Google's Content API.}
+  spec.homepage      = "https://github.com/dawanda/google-content-api"
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.13"
+  spec.add_development_dependency "webmock", "~> 1.11.0"
+  spec.add_dependency  "google-api-client", "~> 0.4"
+  spec.add_dependency  "nokogiri", "~> 1.5"
+
+end

data/lib/google_content_api.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+require 'nokogiri'
+require 'google/api_client'
+
+require 'google_content_api/version'
+require 'google_content_api/authorization'
+require 'google_content_api/sub_account'
+require 'google_content_api/product'
+
+module GoogleContentApi
+  def self.config(options = {})
+    @@config ||= YAML.load( File.read(options[:config_file] || "config/google_content_api.yml") )
+  end
+
+  def self.urls(type, account_id, options = {})
+    base_url = "https://content.googleapis.com/content/v1/#{account_id}"
+    url = case type
+          when "managed_accounts"
+            "#{base_url}/managedaccounts"
+          when "products"
+            "#{base_url}/items/products/schema/batch?warnings"
+          when "item", "product"
+            raise "must supply language, country and item id" \
+              if options[:language].nil? || options[:country].nil? || options[:item_id].nil?
+
+            "#{base_url}/items/products/generic/online:#{options[:language].downcase}:#{options[:country].upcase}:#{options[:item_id]}?warnings"
+          else
+            raise "unknown zone"
+          end
+
+    options[:dry_run] ? url + "&dry-run" : url
+  end
+end

data/lib/google_content_api/authorization.rb

@@ -0,0 +1,36 @@
+module GoogleContentApi
+
+  class Authorization
+    class << self
+
+      def fetch_token
+        @@client ||= Google::APIClient.new(
+          :application_name    => GoogleContentApi.config["application_name"],
+          :application_version => GoogleContentApi.config["application_version"]
+        )
+
+        @@client.authorization.client_id     = GoogleContentApi.config["client_id"]
+        @@client.authorization.client_secret = GoogleContentApi.config["client_secret"]
+        @@client.authorization.redirect_uri  = GoogleContentApi.config["redirect_uri"]
+        @@client.authorization.refresh_token = GoogleContentApi.config["refresh_token"]
+        @@client.authorization.scope         = GoogleContentApi.config["content_api_scope"]
+
+        refresh_token
+      end
+
+      private
+        def refresh_token
+          @@token_date ||= nil
+          time_now = Time.now
+          if @@token_date.nil? || (@@token_date + 120 < time_now)
+            @@client.authorization.fetch_access_token!
+            @@token_date = time_now
+          end
+          @@client.authorization.access_token
+        end
+          # p.s - we can consider using:
+          # client.authorization.update_token!
+    end
+  end
+
+end

data/lib/google_content_api/product.rb

@@ -0,0 +1,152 @@
+module GoogleContentApi
+
+  class Product
+    class << self
+
+      def create_products(sub_account_id, products, dry_run = false)
+        token            = Authorization.fetch_token
+        products_url     = GoogleContentApi.urls("products", sub_account_id, :dry_run => dry_run)
+        xml              = create_product_items_batch_xml(products)
+        Faraday.headers  = {
+          "Content-Type"   => "application/atom+xml",
+          "Authorization"  => "AuthSub token=#{token}"
+        }
+
+        response = Faraday.post products_url, xml
+
+        if response.status == 200
+          response
+        else
+          raise "Unable to batch insert products - received status #{response.status}. body: #{response.body}"
+        end
+      end
+      alias_method :create_items, :create_products
+
+      def delete(sub_account_id, params)
+        token           = Authorization.fetch_token
+        product_url     = GoogleContentApi.urls("product", sub_account_id, :language => params[:language], :country => params[:country], :item_id => params[:item_id], :dry_run => params[:dry_run])
+        Faraday.headers = { "Authorization" => "AuthSub token=#{token}" }
+
+        response = Faraday.delete product_url
+
+        if response.status == 200
+          response
+        else
+          raise "Unable to delete product - received status #{response.status}. body: #{response.body}"
+        end
+      end
+
+      def create
+        raise "not implemented"
+      end
+
+      def update
+        raise "not implemented"
+      end
+
+      private
+        def create_item_xml(item)
+          item[:id] = item_url(item[:id])
+
+          Nokogiri::XML::Builder.new do |xml|
+            xml.entry(
+                'xmlns'     => 'http://www.w3.org/2005/Atom',
+                'xmlns:app' => 'http://www.w3.org/2007/app',
+                'xmlns:sc'  => 'http://schemas.google.com/structuredcontent/2009',
+                'xmlns:scp' => 'http://schemas.google.com/structuredcontent/2009/products',
+                'xmlns:gd'  => 'http://schemas.google.com/g/2005') do
+              add_mandatory_values(xml, item)
+              add_optional_values(xml, item)
+            end
+          end.to_xml
+        end
+
+        def create_product_items_batch_xml(items)
+          Nokogiri::XML::Builder.new do |xml|
+            xml.feed('xmlns' => 'http://www.w3.org/2005/Atom', 'xmlns:batch' => 'http://schemas.google.com/gdata/batch') do
+              items.each do |attributes|
+                xml.entry('xmlns' => 'http://www.w3.org/2005/Atom', 'xmlns:sc' => 'http://schemas.google.com/structuredcontent/2009', 'xmlns:scp' => 'http://schemas.google.com/structuredcontent/2009/products', 'xmlns:app' => 'http://www.w3.org/2007/app') do
+                  xml['batch'].operation_(:type => 'INSERT')
+                  add_mandatory_values(xml, attributes)
+                  add_optional_values(xml, attributes)
+                end
+              end
+            end
+          end.to_xml
+        end
+
+        def add_mandatory_values(xml, attributes)
+          xml['batch'].id_ attributes[:id]
+          xml['sc'].id_ attributes[:id]
+          xml.title_ attributes[:title]
+          xml.content_ attributes[:description], :type => 'text'
+          xml.link_(:rel => 'alternate', :type => 'text/html', :href => attributes[:link])
+          xml['sc'].image_link_ attributes[:image]
+          xml['sc'].content_language_ attributes[:content_language]
+          xml['sc'].target_country_   attributes[:target_country]
+          xml['scp'].availability_ attributes[:availability]
+          xml['scp'].condition_(attributes[:condition] != 9 ? "new" : "used")
+          xml['scp'].price_ attributes[:price], :unit => attributes[:currency]
+        end
+
+        def add_optional_values(xml, attributes)
+          if attributes[:expiration_date]
+            xml['sc'].expiration_date_  attributes[:expiration_date]
+          end
+          if attributes[:adult]
+            xml['sc'].adult_ attributes[:adult]
+          end
+          if attributes[:additional_images]
+            attributes[:additional_images].each { |image_link| xml['sc'].additional_image_link_ }
+          end
+          if attributes[:product_type]
+            xml['scp'].product_type_ attributes[:product_type]
+          end
+          if attributes[:google_product_category]
+            xml['scp'].google_product_category_ attributes[:google_product_category]
+          end
+          if attributes[:brand]
+            xml['scp'].brand_ attributes[:brand]
+          end
+          if attributes[:mpn]
+            xml['scp'].mpn_ attributes[:mpn]
+          end
+          if attributes[:adwords_grouping]
+            xml['scp'].adwords_grouping_ attributes[:adwords_grouping]
+          end
+          if attributes[:adwords_labels]
+            xml['scp'].adwords_labels_ attributes[:adwords_labels]
+          end
+          if attributes[:adwords_redirect]
+            xml['scp'].adwords_redirect_ attributes[:adwords_redirect]
+          end
+          if attributes[:shipping]
+            xml['scp'].shipping_ do
+              xml['scp'].shipping_country_ attributes[:shipping][:shipping_country]
+              xml['scp'].shipping_price_ attributes[:shipping][:shipping_price], :unit => attributes[:currency]
+              xml['scp'].shipping_service_ attributes[:shipping][:shipping_service]
+            end
+          end
+          if attributes[:size]
+            xml['scp'].size_ attributes[:size]
+          end
+          if attributes[:gender]
+            xml['scp'].gender_ attributes[:gender]
+          end
+          if attributes[:age_group]
+            xml['scp'].age_group_ attributes[:age_group]
+          end
+          if attributes.has_key?(:identifier_exists)
+            xml['scp'].identifier_exists_ attributes[:identifier_exists]
+          end
+          if attributes[:unit_pricing_base_measure] && attributes[:unit]
+            xml['scp'].unit_pricing_base_measure_ attributes[:unit_pricing_base_measure], :unit => attributes[:unit]
+          end
+          if attributes[:unit_pricing_measure] && attributes[:unit]
+            xml['scp'].unit_pricing_measure_ attributes[:unit_pricing_measure], :unit => attributes[:unit]
+          end
+        end
+    end
+  end
+
+end

data/lib/google_content_api/sub_account.rb

@@ -0,0 +1,95 @@
+module GoogleContentApi
+
+  class SubAccount
+    class << self
+
+      def get_all
+        token            = Authorization.fetch_token
+        sub_accounts_url = GoogleContentApi.urls("managed_accounts", google_user_id)
+        Faraday.headers  = {
+          "Content-Type"  => "application/atom+xml",
+          "Authorization" => "AuthSub token=#{token}"
+        }
+
+        response = Faraday.get sub_accounts_url
+
+        if response.status == 200
+          response
+        else
+          raise "request unsuccessful - received status #{response.status}"
+        end
+      end
+
+      def create(title, adult_content = false, attributes = {})
+        prepare_request_params(title, adult_content, attributes)
+        response = Faraday.post @sub_accounts_url, @xml
+
+        if response.status == 201
+          response
+        else
+          raise "Unable to create sub account - received status #{response.status}. body: #{response.body}"
+        end
+      end
+
+      def update(title, google_id, adult_content = false, attributes = {})
+        prepare_request_params(title, adult_content, attributes)
+        response = Faraday.put "#{@sub_accounts_url}/#{google_id}", @xml
+
+        if response.status == 200
+          response
+        else
+          raise "Unable to update sub account - received status #{response.status}. body: #{response.body}"
+        end
+      end
+
+      def delete(google_id)
+        token           = Authorization.fetch_token
+        sub_account_url = GoogleContentApi.urls("managed_accounts", google_user_id)
+        Faraday.headers = { "Authorization"  => "AuthSub token=#{token}" }
+        response        = Faraday.delete "#{sub_account_url}/#{google_id}"
+
+        if response.status == 200
+          response
+        else
+          raise "Unable to delete sub account - received status #{response.status}. body: #{response.body}"
+        end
+      end
+
+      private
+        def prepare_request_params(title, adult_content = false, attributes = {})
+          @token            = Authorization.fetch_token
+          @sub_accounts_url = GoogleContentApi.urls("managed_accounts", google_user_id)
+          @xml              = create_xml(title, adult_content, attributes)
+          Faraday.headers  = set_headers(@token, @xml.length)
+        end
+
+        def set_headers(token, length = 0)
+          {
+            "Content-Type"   => "application/atom+xml",
+            "Content-Length" => length.to_s,
+            "Authorization"  => "AuthSub token=#{token}"
+          }
+        end
+
+        def create_xml(title, adult_content = false, attributes = {})
+          adult_content = !adult_content ? "no" : "yes"
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.entry('xmlns' => 'http://www.w3.org/2005/Atom', 'xmlns:sc' => 'http://schemas.google.com/structuredcontent/2009') do
+              xml.title_ title
+              xml['sc'].adult_content adult_content
+              xml.content_ attributes[:description]                     if attributes[:description]
+              xml.link_(:rel => 'alternate', :type => 'text/html', :href => attributes[:link]) if attributes[:link]
+              xml['sc'].internal_id_ attributes[:internal_id]           if attributes[:internal_id]
+              xml['sc'].reviews_url_ attributes[:reviews_url]           if attributes[:reviews_url]
+              xml['sc'].adwords_accounts_ attributes[:adwords_accounts] if attributes[:adwords_accounts]
+            end
+          end.to_xml
+        end
+
+        def google_user_id
+          GoogleContentApi.config["user_id"]
+        end
+    end
+  end
+
+end

data/lib/google_content_api/version.rb

@@ -0,0 +1,3 @@
+module GoogleContentApi
+  VERSION = "0.1.2"
+end

data/spec/google_content_api/authorization_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GoogleContentApi::Authorization do
+  subject { GoogleContentApi::Authorization }
+
+  describe ".refresh_token" do
+    context "when 2 minutes didn't pass" do
+      it "doesn't call fetch_access_token!" do
+        subject.send :class_variable_set, :@@token_date, Time.now
+        Signet::OAuth2::Client.any_instance.should_not_receive(:fetch_access_token!)
+        subject.fetch_token
+      end
+    end
+
+    context "when 2 minutes have passed" do
+      it "calls fetch_access_token!" do
+        subject.send :class_variable_set, :@@token_date, Time.now - 121
+        Signet::OAuth2::Client.any_instance.should_receive(:fetch_access_token!)
+        subject.fetch_token
+      end
+    end
+  end
+
+  describe ".fetch_token" do
+    it "always returns a token" do
+      Signet::OAuth2::Client.any_instance.stub(:fetch_access_token!)
+      Signet::OAuth2::Client.any_instance.stub(:access_token).and_return(fake_token)
+      2.times { subject.fetch_token.should == fake_token }
+    end
+  end
+end

data/spec/google_content_api/product_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe GoogleContentApi::Product do
+  subject { GoogleContentApi::Product }
+  it { should respond_to(:create_products) }
+  let(:sub_account_id) { "9898988" }
+  let(:product_id) { "123123" }
+  let(:dry_run) { true }
+  let(:successful_response) { OpenStruct.new(:status => 200) }
+  let(:product_attributes) {
+    {
+      :id               => "x",
+      :title            => "Title",
+      :description      => "desc",
+      :link             => "http://testing.is/fun",
+      :image            => "http://testing.is/fun.jpg",
+      :content_language => "en",
+      :target_country   => "US",
+      :currency         => "USD",
+      :price            => 0.99,
+      :condition        => "new"
+    }
+  }
+
+  describe ".create_products" do
+    it "status == 200" do
+      GoogleContentApi::Authorization.should_receive(:fetch_token).once.and_return(fake_token)
+      stub_request(:post, GoogleContentApi.urls("products", sub_account_id, :dry_run => dry_run)).
+        with(:headers => {
+          'Content-Type'  => 'application/atom+xml',
+          'Authorization' => "AuthSub token=#{fake_token}"
+        }).to_return(:status => 200)
+
+      subject.create_products(sub_account_id, [], dry_run).status.should == 200
+    end
+  end
+
+  describe ".delete" do
+    it "status == 200" do
+      GoogleContentApi::Authorization.stub(:fetch_token).and_return(fake_token)
+      Faraday.stub(:delete).and_return(successful_response)
+      subject.delete(sub_account_id, :language => "de", :country => "de", :item_id => product_id).status.should == 200
+    end
+  end
+
+  describe "private" do
+    describe ".create_product_items_batch_xml" do
+      it "creates an xml with all given product attributes" do
+        result_xml = subject.send(:create_product_items_batch_xml, [product_attributes])
+
+        result_xml.should match 'xmlns:batch="http://schemas.google.com/gdata/batch">'
+        result_xml.should match 'xmlns:scp="http://schemas.google.com/structuredcontent/2009/products"'
+        product_attributes.each { |attribute, value| result_xml.should match /#{value}/ }
+      end
+
+      it "calls .add_optional_values" do
+        GoogleContentApi::Authorization.stub(:fetch_token).and_return(fake_token)
+        Faraday.stub(:post).and_return(successful_response)
+
+        subject.should_receive(:add_optional_values).once
+        subject.create_products(sub_account_id, [product_attributes], dry_run)
+      end
+    end
+
+    describe ".add_optional_values" do
+      let(:unit) { "g" }
+      let(:unit_pricing_measure) { 100 }
+      it "creates the xml with the given optional values" do
+        result_xml = subject.send(:create_product_items_batch_xml, [product_attributes.merge(:unit => unit, :unit_pricing_measure => unit_pricing_measure)])
+        result_xml.should match "<scp:unit_pricing_measure unit=\"#{unit}\">#{unit_pricing_measure}</scp:unit_pricing_measure>"
+      end
+    end
+  end
+end

data/spec/google_content_api/sub_account_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe GoogleContentApi::SubAccount do
+    subject { GoogleContentApi::SubAccount }
+    let(:user_id) { GoogleContentApi.config["user_id"] }
+    let(:example_create_xml) { %Q|<?xml version=\"1.0\"?>\n<entry xmlns:sc=\"http://schemas.google.com/structuredcontent/2009\" xmlns=\"http://www.w3.org/2005/Atom\">\n  <title>#{sub_account_name}</title>\n  <sc:adult_content>no</sc:adult_content>\n</entry>\n| }
+    let(:sub_account_name) { "test account" }
+
+    it { should respond_to(:create) }
+    it { should respond_to(:get_all) }
+    it { should respond_to(:delete) }
+
+    describe ".create" do
+      it "creates a sub account" do
+        subject.should_receive(:create_xml).
+          once.with(sub_account_name, false, {}).and_return(example_create_xml)
+        GoogleContentApi::Authorization.should_receive(:fetch_token).once.and_return(fake_token)
+
+        stub_request(:post, GoogleContentApi.urls("managed_accounts", user_id)).
+          with(
+            :body => example_create_xml,
+            :headers => {
+              'Accept'=>'*/*',
+              'Authorization' => "AuthSub token=#{fake_token}",
+              'Content-Length' => example_create_xml.length.to_s,
+              'Content-Type' => 'application/atom+xml'
+              }).to_return(
+                :status => 201,
+                :body => "<entry xmlns='...'>stuff</entry>")
+
+        response = subject.create(sub_account_name, false)
+        response.status.should == 201
+      end
+    end
+
+    describe ".update" do
+      let(:existing_google_id) { "123456" }
+      it "updates a sub account" do
+        subject.should_receive(:create_xml).
+          once.with(sub_account_name, false, {}).and_return(example_create_xml)
+        GoogleContentApi::Authorization.should_receive(:fetch_token).once.and_return(fake_token)
+
+        url = GoogleContentApi.urls("managed_accounts", user_id)
+        stub_request(:put, "#{url}/#{existing_google_id}").
+          with(
+            :body => example_create_xml,
+            :headers => {
+              'Accept'=>'*/*',
+              'Authorization' => "AuthSub token=#{fake_token}",
+              'Content-Length' => example_create_xml.length.to_s,
+              'Content-Type' => 'application/atom+xml'
+              }).to_return(
+                :status => 200,
+                :body => "<entry xmlns='...'>stuff</entry>")
+
+        response = subject.update(sub_account_name, existing_google_id, false)
+        response.status.should == 200
+      end
+    end
+
+    describe ".get_all" do
+      before(:each) do
+        GoogleContentApi::Authorization.should_receive(:fetch_token).once.and_return(fake_token)
+      end
+
+      context "when status == 200" do
+        it "returns the response" do
+
+          stub_request(:get, GoogleContentApi.urls("managed_accounts", user_id)).
+            with(:headers => {
+              'Accept'=>'*/*',
+              'Authorization' => "AuthSub token=#{fake_token}",
+              'Content-Type'  => 'application/atom+xml'
+            }).to_return(
+              :status => 200,
+              :body => "<entry xmlns='...'>blah blah</entry>")
+
+          response = subject.get_all
+          response.status.should == 200
+        end
+      end
+
+      context "when status != 200" do
+        it "raises an error" do
+          stub_request(:get, GoogleContentApi.urls("managed_accounts", user_id)).
+            with(:headers => {
+              'Accept'=>'*/*',
+              'Authorization' => "AuthSub token=#{fake_token}",
+              'Content-Type'  => 'application/atom+xml'
+            }).to_return(
+              :status => 400,
+              :body => "<entry xmlns='...'>blah blah</entry>")
+
+          expect { subject.get_all }.to raise_error
+        end
+      end
+    end
+
+    describe ".delete" do
+      let(:sub_account_id) { "555555" }
+      let(:delete_url) { GoogleContentApi.urls("managed_accounts", user_id) + "/#{sub_account_id}" }
+
+      context "when status == 200" do
+        it "returns the response" do
+          GoogleContentApi::Authorization.should_receive(:fetch_token).once.and_return(fake_token)
+          Faraday.should_receive(:delete).
+            with(delete_url).
+            and_return( double("response", :status => 200) )
+
+          response = subject.delete sub_account_id
+          response.status.should == 200
+        end
+      end
+
+      context "when status != 200" do
+        let(:example_delete_error_xml) { %Q|<?xml version='1.0' encoding='UTF-8'?><errors xmlns='http://schemas.google.com/g/2005'><error><domain>GData</domain><code>ResourceNotFoundException</code><internalReason>Managed account 15794381 not found</internalReason></error></errors>| }
+
+        it "raises error" do
+          GoogleContentApi::Authorization.should_receive(:fetch_token).once.and_return(fake_token)
+          Faraday.should_receive(:delete).
+            with(delete_url).
+            and_return( double("response",
+              :status => 404,
+              :body => example_delete_error_xml) )
+
+          expect { subject.delete(sub_account_id) }.to raise_error
+        end
+      end
+    end
+  end

data/spec/google_content_api_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe GoogleContentApi do
+  it { should respond_to(:config) }
+  it { should respond_to(:urls) }
+
+  it "should have a config" do
+    subject.config.should be_kind_of(Hash)
+  end
+
+  it "has a version" do
+    GoogleContentApi::VERSION.should_not be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'webmock/rspec'
+require ::File.expand_path("../lib/google_content_api", File.dirname(__FILE__))
+
+RSpec.configure do |config|
+  config.order = 'random'
+end
+
+def fake_token
+ "foobarbaz"
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: google-content-api
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- DaWanda GmbH
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-29 00:00:00.000000000 Z
+dependencies:
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Gem for interacting with Google's Content API.
+email:
+- amir@dawanda.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/google_content_api.example
+- google-content-api.gemspec
+- lib/google_content_api.rb
+- lib/google_content_api/authorization.rb
+- lib/google_content_api/product.rb
+- lib/google_content_api/sub_account.rb
+- lib/google_content_api/version.rb
+- spec/google_content_api/authorization_spec.rb
+- spec/google_content_api/product_spec.rb
+- spec/google_content_api/sub_account_spec.rb
+- spec/google_content_api_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dawanda/google-content-api
+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.1.1
+signing_key: 
+specification_version: 4
+summary: Gem for interacting with Google's Content API.
+test_files:
+- spec/google_content_api/authorization_spec.rb
+- spec/google_content_api/product_spec.rb
+- spec/google_content_api/sub_account_spec.rb
+- spec/google_content_api_spec.rb
+- spec/spec_helper.rb