usergrid_ironhorse 0.0.2

data/lib/usergrid_ironhorse/user_context.rb

@@ -0,0 +1,79 @@
+module Usergrid
+  module Ironhorse
+    module UserContext
+
+      # returns user if logged in, nil otherwise
+      # if session is passed, stores user_id and auth_token in the session
+      # and sets User as current_user
+      def authenticate(username, password, session=nil)
+        application = Usergrid::Application.new Usergrid::Ironhorse::Base.settings[:application_url]
+        begin
+          application.login username, password
+          user = new application.current_user.data
+          if session
+            session[:usergrid_user_id] = user.id
+            session[:usergrid_auth_token] = user.current_auth_token
+            set_thread_context(session)
+            Thread.current[:usergrid_current_user] = user
+          end
+          user
+        rescue
+          Rails.logger.info $!
+          raise $!
+        end
+      end
+
+      # clears auth from session and thread
+      def clear_authentication(session)
+        session[:usergrid_user_id] = nil
+        session[:usergrid_auth_token] = nil
+        clear_thread_context(session)
+      end
+
+      # allows admin actions to be done in a block
+      def as_admin(&block)
+        save_user_id = Thread.current[:usergrid_user_id]
+        save_auth_token = Thread.current[:usergrid_auth_token]
+        save_user = Thread.current[:usergrid_current_user]
+        begin
+          Thread.current[:usergrid_user_id] = nil
+          Thread.current[:usergrid_auth_token] = Base.settings[:auth_token]
+          Thread.current[:usergrid_current_user] = nil
+          yield block
+        ensure
+          Thread.current[:usergrid_user_id] = save_user_id
+          Thread.current[:usergrid_auth_token] = save_auth_token
+          Thread.current[:usergrid_current_user] = save_user
+        end
+      end
+
+      # sets auth for current thread
+      def set_thread_context(session)
+        Thread.current[:usergrid_user_id] = session[:usergrid_user_id]
+        Thread.current[:usergrid_auth_token] = session[:usergrid_auth_token]
+        Thread.current[:usergrid_current_user] = nil
+      end
+
+      # clears auth from current thread
+      def clear_thread_context(session)
+        Thread.current[:usergrid_user_id] = nil
+        Thread.current[:usergrid_auth_token] = nil
+        Thread.current[:usergrid_current_user] = nil
+      end
+
+      # returns the auth token for the current thread
+      def current_auth_token
+        Thread.current[:usergrid_auth_token]
+      end
+
+      # does a find and return
+      def current_user
+        unless Thread.current[:usergrid_current_user]
+          Thread.current[:usergrid_current_user] = find(Thread.current[:usergrid_user_id]) if Thread.current[:usergrid_user_id]
+        end
+        Thread.current[:usergrid_current_user]
+      end
+
+    end
+  end
+end

data/lib/usergrid_ironhorse/version.rb

@@ -0,0 +1,5 @@
+module Usergrid
+  module Ironhorse
+    VERSION = '0.0.2'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+require 'simplecov'
+require 'test/unit'
+require 'rspec'
+require 'yaml'
+require 'securerandom'
+require_relative '../lib/usergrid_ironhorse'
+
+ENV["RAILS_ENV"] ||= 'test'
+Dir[Pathname.new(File.dirname(__FILE__)).join("support/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.expect_with :stdlib
+  config.expect_with :rspec
+end
+
+LOG = Logger.new(STDOUT)
+RestClient.log=LOG
+
+SimpleCov.at_exit do
+  SimpleCov.result.format!
+  #index = File.join(SimpleCov.coverage_path, 'index.html')
+  #`open #{index}` if File.exists?(index)
+end
+SimpleCov.start
+
+
+SPEC_SETTINGS = YAML::load_file(File.join File.dirname(__FILE__), 'spec_settings.yaml')
+
+def login_management
+  management = Usergrid::Resource.new(SPEC_SETTINGS[:api_url]).management
+  management.login SPEC_SETTINGS[:organization][:username], SPEC_SETTINGS[:organization][:password]
+  management
+end
+
+# ensure we are correctly setup (management login & organization)
+management = login_management
+
+begin
+  management.create_organization(SPEC_SETTINGS[:organization][:name],
+                                 SPEC_SETTINGS[:organization][:username],
+                                 SPEC_SETTINGS[:organization][:username],
+                                 "#{SPEC_SETTINGS[:organization][:username]}@email.com",
+                                 SPEC_SETTINGS[:organization][:password])
+  LOG.info "created organization with user #{SPEC_SETTINGS[:organization][:username]}@email.com"
+rescue
+  if MultiJson.load($!.response)['error'] == "duplicate_unique_property_exists"
+    LOG.debug "test organization exists"
+  else
+    raise $!
+  end
+end
+
+def create_random_application
+  management = login_management
+  organization = management.organization SPEC_SETTINGS[:organization][:name]
+
+  app_name = "_test_app_#{SecureRandom.hex}"
+  organization.create_application app_name
+  management.application SPEC_SETTINGS[:organization][:name], app_name
+end
+
+def delete_application(application)
+  management = login_management
+  application.auth_token = management.auth_token
+  application.delete rescue nil  # not implemented on server yet
+end
+
+def create_random_user(application, login=false)
+  random = SecureRandom.hex
+  user_hash = {username: "username_#{random}",
+               password: random,
+               email:    "#{random}@email.com",
+               name:     "#{random} name" }
+  entity = application['users'].post(user_hash).entity
+  application.login user_hash[:username], user_hash[:password] if login
+  entity
+end

data/spec/spec_settings.yaml

@@ -0,0 +1,5 @@
+:api_url: http://localhost:8080
+:organization:
+  :name: test-organization
+  :username: test
+  :password: test

data/spec/support/active_model_lint.rb

@@ -0,0 +1,17 @@
+# spec/support/active_model_lint.rb
+# adapted from rspec-rails: http://github.com/rspec/rspec-rails/blob/master/spec/rspec/rails/mocks/mock_model_spec.rb
+
+shared_examples_for "ActiveModel" do
+  include ActiveModel::Lint::Tests
+
+  # to_s is to support ruby-1.9
+  ActiveModel::Lint::Tests.public_instance_methods.map{|m| m.to_s}.grep(/^test/).each do |m|
+    example m.sub('_',' ') do
+      send m
+    end
+  end
+
+  def model
+    subject
+  end
+end

data/spec/usergrid_ironhorse/base_spec.rb

@@ -0,0 +1,283 @@
+describe Usergrid::Ironhorse::Base do
+
+  it_should_behave_like 'ActiveModel'
+
+  before :all do
+    @application = create_random_application
+    Foo.configure!(@application.url, @application.auth_token)
+    @user = create_random_user @application, true
+    @foo = (@application.create_entity 'foos', name: 'foo42', answer: 42).entity
+  end
+
+  after :all do
+    @foo.delete
+    @user.delete
+    #delete_application @application
+  end
+
+  class Foo < Usergrid::Ironhorse::Base; end
+  Foo.validates :name, :presence => true
+
+  class Bar < Usergrid::Ironhorse::Base; end
+
+  describe 'subclasses should be able to' do
+
+    it 'be created and destroyed' do
+      foo = Foo.create name: 'foo2'
+      foo.persisted?.should be_true
+      foo.name.should eq 'foo2'
+      foo.destroy.should be_true
+      foo.persisted?.should be_false
+      foo = Foo.find_by_name 'foo2'
+      foo.should be_nil
+    end
+
+    it 'be changed and saved' do
+      foo = Foo.find_by_name @foo.name
+      foo.answer.should eq @foo.answer
+      foo.number = 43
+      foo.changed?.should be_true
+      foo.number.should == 43
+      foo.save!
+      foo = Foo.find_by_name @foo.name
+      foo.number.should == 43
+    end
+
+    it 'be reloaded' do
+      foo = Foo.find @foo.uuid
+      foo.answer = 44
+      foo.changed?.should be_true
+      foo.answer.should == 44
+      foo.reload
+      foo.answer.should == 42
+    end
+
+    it 'be found using find_by_name' do
+      foo = Foo.find_by_name @foo.name
+      foo.uuid.should_not be_nil
+      foo.name.should eq @foo.name
+      foo.should be_a Foo
+      foo.persisted?.should be_true
+    end
+
+    it 'be found using find_by_name!' do
+      foo = Foo.find_by_name! @foo.name
+      foo.uuid.should_not be_nil
+      foo.name.should eq @foo.name
+      foo.should be_a Foo
+      foo.persisted?.should be_true
+    end
+
+    it 'throw a RecordNotFound when find_by_name! misses' do
+      expect { Foo.find_by_name! 'name3' }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    it 'add a validation' do
+      foo = Foo.new
+      foo.valid?.should be_false
+      foo.name = 'joe'
+      foo.valid?.should be_true
+    end
+
+    it 'fail to save an invalid record and save the errors' do
+      foo = Foo.new
+      foo.save.should be_false
+      foo.persisted?.should be_false
+      foo.errors.count.should == 1
+      foo.errors.get(:name).first.should eq "can't be blank"
+    end
+
+    it 'fail to create an invalid record and save the errors' do
+      foo = Foo.create
+      foo.persisted?.should be_false
+      foo.errors.count.should == 1
+      foo.errors.get(:name).first.should eq "can't be blank"
+    end
+
+    it 'fail to save! an invalid record' do
+      expect { Foo.new.save! }.to raise_error(ActiveRecord::RecordNotSaved)
+    end
+
+    it 'fail to create! an invalid record' do
+      expect { Foo.create! }.to raise_error(ActiveRecord::RecordNotSaved)
+    end
+
+    it 'retrieve first' do
+      foo2 = Foo.create! name: 'foo2'
+      foo = Foo.first
+      foo.uuid.should eq @foo.uuid
+      foo2.destroy
+    end
+
+    it 'retrieve last' do
+      foo2 = Foo.create! name: 'foo2'
+      foo = Foo.last
+      foo.uuid.should eq foo2.uuid
+      foo2.destroy
+    end
+
+    it 'take multiple' do
+      foo2 = Foo.create! name: 'foo2'
+      foos = Foo.take(2)
+      foos.size.should == 2
+      foos.first.uuid.should_not be_nil
+      foo2.destroy
+    end
+
+    it 'find multiple by id' do
+      foo2 = Foo.create name: 'foo2'
+      foos = Foo.find @foo.uuid, foo2.uuid
+      foos.size.should == 2
+      foos.first.uuid.should eq @foo.uuid
+      foos.last.uuid.should eq foo2.uuid
+      foo2.destroy
+    end
+
+    it 'find multiple by name' do
+      foo2 = Foo.create! name: 'foo2'
+      foos = Foo.find @foo.name, foo2.name
+      foos.size.should == 2
+      foos.first.uuid.should eq @foo.uuid
+      foos.last.uuid.should eq foo2.uuid
+      foo2.destroy
+    end
+
+    it 'check exists?(string)' do
+      Foo.exists?(@foo.name).should be_true
+    end
+
+    it 'check not exists?(string)' do
+      Foo.exists?('asdfasdf').should be_false
+    end
+
+    it 'check exists?(Array)' do
+      Foo.exists?(['name = ?', @foo.name]).should be_true
+    end
+
+    it 'check not exists?(Array)' do
+      Foo.exists?(['name = ?', 'asdfasdf']).should be_false
+    end
+
+    it 'check exists?(Hash)' do
+      Foo.exists?(name: @foo.name).should be_true
+    end
+
+    it 'check not exists?(Hash)' do
+      Foo.exists?(name: 'asfasdf').should be_false
+    end
+
+    it 'check exists?(nil)' do
+      Foo.exists?.should be_true
+    end
+
+    it 'check not exists?(nil)' do
+      Bar.exists?.should be_false
+    end
+
+    it 'perform first_or_create where found' do
+      foo = Foo.where(name: @foo.name).first_or_create
+      foo.uuid.should eq @foo.uuid
+    end
+
+    it 'perform first_or_create where not found' do
+      foo = Foo.where(name: 'foo2').first_or_create(number: 42)
+      foo.name.should eq 'foo2'
+      foo.number.should == 42
+      foo.destroy
+    end
+
+    it 'perform first_or_create! where found' do
+      foo = Foo.where(name: @foo.name).first_or_create!
+      foo.uuid.should eq @foo.uuid
+    end
+
+    it 'perform first_or_create! where not found' do
+      expect { Foo.where(nuumber: 'foo2').first_or_create! }.to raise_error(ActiveRecord::RecordNotSaved)
+    end
+
+    it 'perform first_or_initialize where found' do
+      foo = Foo.where(name: @foo.name).first_or_initialize(xxx: 42)
+      foo.uuid.should eq @foo.uuid
+      foo.xxx.should be_nil
+    end
+
+    it 'perform first_or_initialize where not found' do
+      foo = Foo.where(name: 'foo2').first_or_initialize(number: 42)
+      foo.name.should eq 'foo2'
+      foo.number.should == 42
+      foo.persisted?.should be_false
+    end
+
+    it "should destroy by id" do
+      foo = Foo.create! name: 'foo'
+      Foo.destroy(foo.id)
+      foo = Foo.find_by_name 'foo'
+      foo.should be_nil
+    end
+
+    it "should destroy by ids" do
+      foo = Foo.create! name: 'foo'
+      foo2 = Foo.create! name: 'foo2'
+      Foo.destroy([foo.id, foo2.id])
+      Foo.find_by_name('foo').should be_nil
+      Foo.find_by_name('foo2').should be_nil
+    end
+
+    it "should destroy_all" do
+      foo = Foo.create! name: 'foo', number: 42
+      foo2 = Foo.create! name: 'foo2', number: 42
+      Foo.destroy_all(number: 42)
+      Foo.find_by_name('foo').should be_nil
+      Foo.find_by_name('foo2').should be_nil
+    end
+
+    it "should delete by id" do
+      foo = Foo.create! name: 'foo'
+      Foo.delete(foo.id)
+      foo = Foo.find_by_name 'foo'
+      foo.should be_nil
+    end
+
+    it "should delete by ids" do
+      foo = Foo.create! name: 'foo'
+      foo2 = Foo.create! name: 'foo2'
+      Foo.delete([foo.id, foo2.id])
+      Foo.find_by_name('foo').should be_nil
+      Foo.find_by_name('foo2').should be_nil
+    end
+
+    it "should delete_all" do
+      foo = Foo.create! name: 'foo', number: 42
+      foo2 = Foo.create! name: 'foo2', number: 42
+      Foo.delete_all(number: 42)
+      Foo.find_by_name('foo').should be_nil
+      Foo.find_by_name('foo2').should be_nil
+    end
+
+    it "should update one" do
+      foo = Foo.create! name: 'foo', number: 42
+      Foo.update foo.uuid, { number: 43 }
+      foo.reload.number.should == 43
+      foo.destroy
+    end
+
+    it "should update multiple" do
+      foo = Foo.create! name: 'foo', number: 42
+      foo2 = Foo.create! name: 'foo2', number: 42
+      updates = { foo.uuid => {number: 43}, foo2.uuid => {number: 44}}
+      Foo.update(updates.keys, updates.values)
+      foo.reload.number.should == 43
+      foo2.reload.number.should == 44
+      foo.destroy
+      foo2.destroy
+    end
+
+    it "should update_all" do
+      foo = Foo.create! name: 'foo', number: 43
+      Foo.where(number: 43).update_all({number: 44})
+      Foo.find_by_number(44).should_not be_nil
+      foo.destroy
+    end
+
+  end
+end