gprov 0.0.3

data/lib/gprov/provision/user.rb

@@ -0,0 +1,132 @@
+# = gprov/provision/user.rb: implementation of the gprov provisioning userentry
+#
+# == Overview
+#
+# implementation of the gprov provisioning userentry
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'gprov'
+require 'gprov/provision/feed'
+require 'gprov/provision/entrybase'
+module GProv
+  module Provision
+    class User < GProv::Provision::EntryBase
+
+      # The :title attribute is only used after the account has been created
+      # TODO implement :none access for attributes. This should be hidden.
+      xmlattr :title, :type => :string, :xpath => "xmlns:title/text()"
+
+      xmlattr :user_name,       :xpath => "apps:login/@userName"
+      xmlattr :suspended,       :xpath => "apps:login/@suspended"
+      xmlattr :ip_whitelisted,  :xpath => "apps:login/@ipWhitelisted"
+      xmlattr :admin,           :xpath => "apps:login/@admin"
+      xmlattr :agreed_to_terms, :xpath => "apps:login/@agreedToTerms"
+      xmlattr :limit,           :xpath => "apps:quota/@limit"
+      xmlattr :family_name,     :xpath => "apps:name/@familyName"
+      xmlattr :given_name,      :xpath => "apps:name/@givenName"
+      xmlattr :change_password_at_next_login, :xpath => "apps:login/@changePasswordAtNextLogin"
+
+      # Adds explicit ordering to attributes for cleaner output
+      def self.attribute_names
+        [
+          :user_name,
+          :given_name,
+          :family_name,
+          :admin,
+          :agreed_to_terms,
+          :change_password_at_next_login,
+          :suspended,
+          :ip_whitelisted,
+          :limit
+        ]
+      end
+
+      # These attributes appear to never be sent from google but can be
+      # posted back
+      attr_accessor :password, :hash_function_name
+
+      # Retrieves all users within a domain
+      def self.all(connection)
+        feed = GProv::Provision::Feed.new(connection, "/:domain/user/2.0", "/xmlns:feed/xmlns:entry")
+        entries = feed.fetch
+        entries.map { |xml| new(:status => :clean, :connection => connection, :source => xml) }
+      end
+
+      def self.get(connection, title, options={})
+        response = connection.get("/:domain/user/2.0/#{title}")
+
+        document = Nokogiri::XML(response.body)
+        xml = document.root
+
+        new(:status => :clean, :connection => connection, :source => xml)
+      end
+
+      # Generate a nokogiri representation of this user
+      def to_nokogiri
+        base_document = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.entry('xmlns:atom' => 'http://www.w3.org/2005/Atom',
+                    'xmlns:apps' => 'http://schemas.google.com/apps/2006' ) {
+
+            # Namespaces cannot be used until they are declared, so we need to
+            # retroactively declare the namespace of the parent
+            xml.parent.namespace = xml.parent.namespace_definitions.select {|ns| ns.prefix == "atom"}.first
+            xml.category("scheme" => "http://schemas.google.com/g/2005#kind",
+                         "term"   =>"http://schemas.google.com/apps/2006#user")
+            xml['apps'].login(login_attributes)
+            xml['apps'].quota("limit" => @limit) if @limit
+            xml['apps'].name("familyName" => @family_name, "givenName" => @given_name)
+          }
+        end
+
+        base_document
+      end
+
+      def create!
+        response = connection.post("/:domain/user/2.0", {:body => to_nokogiri.to_xml})
+        status = :clean
+      end
+
+      def update!
+        response = connection.put("/:domain/user/2.0/#{title}", {:body => to_nokogiri.to_xml})
+        status = :clean
+      end
+
+      def delete!
+        response = connection.delete("/:domain/user/2.0/#{title}")
+        status = :deleted
+      end
+
+      private
+
+      # Map object properties to xml tag attributes
+      def login_attributes
+        attrs = {}
+
+        attr_pairs = [
+          {"userName"                  => @user_name},
+          {"suspended"                 => @suspended},
+          {"ipWhitelisted"             => @ip_whitelisted},
+          {"admin"                     => @admin},
+          {"changePasswordAtNextLogin" => @change_password_at_next_login},
+          {"agreedToTerms"             => @agreed_to_terms},
+          {'password'                  => @password},
+          {'hashFunctionName'          => @hash_function_name},
+        ]
+
+        attr_pairs.each do |pair|
+          key = pair.keys.first
+          attrs.merge!(pair) unless pair[key].nil?
+        end
+
+        attrs
+      end
+    end
+  end
+end

data/lib/gprov/version.rb

@@ -0,0 +1,3 @@
+module GProv
+  VERSION = "0.0.3"
+end

data/spec/gdata/auth/clientlogin_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe GProv::Auth::ClientLogin do
+
+  before :each do
+    @klass = GProv::Auth::ClientLogin
+    @instance = @klass.new('test', 'password', 'service')
+    @dummy_form = {:body => {
+      "accountType" => "HOSTED",
+      "Email"       => "test",
+      "Passwd"      => "password",
+      "service"     => "service",
+    }}
+  end
+
+  it "should use the google ClientLogin uri" do
+    GProv::Auth::ClientLogin.base_uri.should == "https://www.google.com/accounts/ClientLogin"
+  end
+
+  it "should have a token method" do
+    @instance.respond_to?(:token).should == true
+  end
+
+  it "should post valid form data to the uri specified base_uri" do
+    stub_response = stub :response
+    stub_response.stubs(:code).returns 200
+    stub_response.stubs(:body).returns "Auth=dummy\n"
+    @klass.expects(:post).with('', @dummy_form).returns stub_response
+    @instance.token
+  end
+
+  it "should return nil if authorization failed" do
+    stub_response = stub :response
+    stub_response.stubs(:code).returns 403
+    @klass.expects(:post).with('', @dummy_form).returns stub_response
+    @instance.token.should be_nil
+  end
+
+  it "should return the token if authorization succeeded" do
+    stub_response = stub :response
+    stub_response.stubs(:code).returns 200
+    stub_response.stubs(:body).returns "Auth=dummy\n"
+    @klass.expects(:post).with('', @dummy_form).returns stub_response
+    @instance.token.should == "dummy"
+  end
+
+end

data/spec/gdata/connection_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe GProv::Connection do
+
+  before :each do
+    @klass = GProv::Connection
+    @instance = @klass.new("domain", "token")
+
+    @expected_options = {:headers => {
+      'Authorization' => "GoogleLogin auth=token",
+      'Content-Type' => 'application/atom+xml',
+    }}
+  end
+
+  it "should use to google apps API url as the base uri" do
+    @klass.base_uri.should == "https://apps-apis.google.com/a/feeds"
+  end
+
+  it "should have a domain accessor" do
+    @instance.respond_to?(:domain).should == true
+  end
+
+  it "should expose the default headers" do
+    @instance.default_headers.should == @expected_options
+  end
+
+
+  describe "http instance method" do
+    [:put, :get, :post, :delete].each do |verb|
+      describe %Q{"#{verb}"} do
+        before do
+          xml = %Q{<?xml version="1.0" encoding="UTF-8"?>\n<test xml="pointy"/>}
+          @stub_request = mock
+          @stub_request.stubs(:code).returns 200
+          @stub_request.stubs(:success?).returns true
+          @stub_request.stubs(:class).returns HTTParty::Response
+        end
+
+        it "should be an instance method" do
+          @instance.respond_to?(verb).should == true
+        end
+
+        it "should be forwarded to the class" do
+          @klass.expects(verb).returns @stub_request
+          @instance.send(verb, '')
+        end
+
+        it "should return the http response" do
+          @klass.expects(verb).returns @stub_request
+          output = @instance.send(verb, "/url")
+          output.class.should == HTTParty::Response
+        end
+
+        it "should interpolate the :domain substring" do
+          @klass.expects(verb).with("/domain", @expected_options).returns @stub_request
+          @instance.send(verb, "/:domain")
+        end
+      end
+    end
+  end
+end
+

data/spec/gdata/provision/entrybase_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class FakeEntry < GProv::Provision::EntryBase
+
+  xml_attr_accessor :test, :xpath => "/foo/bar/text()"
+  xml_attr_accessor :test_transform, :xpath => "/foo/bar/text()", :transform => lambda {|x| x.upcase}
+end
+
+describe GProv::Provision::EntryBase do
+
+  before do
+    @klass = GProv::Provision::EntryBase
+    @test_klass = FakeEntry
+    @instance = @test_klass.new
+  end
+
+  describe GProv::Provision::EntryBase::ClassMethods do
+
+    [:xml_attr_accessor, :xml_to_hash, :attributes].each do |method|
+      it "method #{method} should be a class method" do
+        FakeEntry.respond_to?(method).should be_true
+      end
+    end
+
+    it "xml_attr_accessor should receive a symbol and hash of attributes" do
+      @test_klass.attributes[:test].should == {:xpath => "/foo/bar/text()"}
+    end
+
+    describe "xml_to_hash" do
+    end
+  end
+
+
+  [:status, :connection].each do |method|
+    it "method #{method} should be an instance method" do
+      @instance.respond_to?(method).should be_true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby -S rspec
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'mocha'
+require 'gprov'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: gprov
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Adrien Thebo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 8
+        version: "0.8"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 5
+        version: "1.5"
+  type: :runtime
+  version_requirements: *id002
+description: Ruby bindings to the Google Provisioning API
+email: adrien@puppetlabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/gprov/auth/clientlogin.rb
+- lib/gprov/auth.rb
+- lib/gprov/connection.rb
+- lib/gprov/error.rb
+- lib/gprov/provision/customerid.rb
+- lib/gprov/provision/entrybase/classmethods.rb
+- lib/gprov/provision/entrybase/xmlattr.rb
+- lib/gprov/provision/entrybase.rb
+- lib/gprov/provision/feed.rb
+- lib/gprov/provision/group.rb
+- lib/gprov/provision/member.rb
+- lib/gprov/provision/orgmember.rb
+- lib/gprov/provision/orgunit.rb
+- lib/gprov/provision/owner.rb
+- lib/gprov/provision/user.rb
+- lib/gprov/provision.rb
+- lib/gprov/version.rb
+- lib/gprov.rb
+- spec/gdata/auth/clientlogin_spec.rb
+- spec/gdata/connection_spec.rb
+- spec/gdata/provision/entrybase_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- Rakefile
+- README.markdown
+homepage: http://github.com/adrienthebo/ruby-gprov
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Ruby bindings to the Google Provisioning API
+test_files: []
+