be_taskable 0.5.0

data/spec/be_taskable/unit/taskable_spec.rb

@@ -0,0 +1,309 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe 'BeTaskable::Taskable' do
+
+	let(:task) { double.as_null_object }
+	let(:assignee) { double.as_null_object }
+	let(:taskable) { Taskable.new }
+	let(:resolver) { double.as_null_object }
+
+	before do
+		taskable.stub(:task_resolver_for_action).and_return(resolver)
+		resolver.stub(:assignees_for_task).and_return([])
+	end
+
+	describe '#_task_resolver_name_for_action' do
+
+		it "responds to _task_resolver_name_for_action" do
+			expect(Taskable).to respond_to('_task_resolver_name_for_action')
+		end
+
+		it "returns the right name" do
+			res = Taskable._task_resolver_name_for_action('publish')
+			expect(res).to eq('TaskablePublishTaskResolver')
+		end
+
+		it "returns the right name for underscored actions" do
+			res = Taskable._task_resolver_name_for_action('publish_something')
+			expect(res).to eq('TaskablePublishSomethingTaskResolver')
+		end
+	end
+
+	describe '#_task_resolver_for_action' do
+
+		it "throws if it cannot find the resolver" do
+			expect{ Taskable._task_resolver_for_action('update') }.to raise_error
+		end
+
+		it "returns the resolver" do
+			res = Taskable._task_resolver_for_action('publish')
+			expect(res).to be_instance_of(TaskablePublishTaskResolver)
+		end
+	end
+
+	it "responds to taskable?" do
+		expect(taskable).to be_taskable
+	end
+
+	describe ".task_resolver_for_action" do
+		it "asks the class" do
+			taskable.unstub(:task_resolver_for_action)
+			action = 'publish'
+			Taskable.should_receive(:_task_resolver_for_action).with(action)
+			taskable.task_resolver_for_action(action)
+		end
+	end
+
+	describe ".tasks" do
+		it "responds to tasks" do
+			expect(taskable).to respond_to('tasks')
+		end
+
+		it "finds the tasks" do
+			taskable.save
+			taskable.tasks.create
+			taskable.tasks.create
+			expect(taskable.tasks.size).to eq(2)
+		end
+	end
+
+	describe ".create_task_for_action" do
+
+		before do
+			taskable.save
+		end
+
+		it "raises if it cannot find the resolver" do
+			taskable.unstub(:task_resolver_for_action)
+			expect{ taskable.create_task_for_action('view') }.to raise_error
+		end
+
+		it "raises if the taskable is not saved" do
+			taskable = Taskable.new
+			expect{ taskable.create_task_for_action('publish') }.to raise_error(ActiveRecord::RecordNotSaved)
+		end
+
+		it "creates a task" do
+			task = taskable.create_task_for_action('publish')
+			expect(taskable.tasks.size).to eq(1)
+		end
+
+		it "creates a different task everytime" do
+			task1 = taskable.create_task_for_action('publish')
+			task2 = taskable.create_task_for_action('publish')
+			expect(taskable.tasks.size).to eq(2)
+		end
+
+		it "has the right taskable" do
+			task = taskable.create_task_for_action('publish')
+			expect(task.taskable).to eq(taskable)
+		end
+
+		it "returns the task with the right action" do
+			task = taskable.create_task_for_action('publish')
+			expect(task.action).to eq('publish')
+		end
+
+		it "calls task.refresh" do
+			task = double.as_null_object
+			task.should_receive(:refresh)
+			taskable.tasks.stub(:create).and_return(task)
+			task = taskable.create_task_for_action('publish')
+		end
+
+		it "calls task.on_creation" do
+			task = double.as_null_object
+			task.should_receive(:on_creation)
+			taskable.tasks.stub(:create).and_return(task)
+			task = taskable.create_task_for_action('publish')
+		end
+	end
+
+	describe ".create_or_refresh_task_for_action" do
+		it "uses an existing task if possible" do
+			taskable.save
+			taskable.create_task_for_action('publish')
+			taskable.should_not_receive(:create_task_for_action)
+			taskable.create_or_refresh_task_for_action('publish')
+		end
+
+		it "creates a new task if not there" do
+			taskable.should_receive(:create_task_for_action)
+			taskable.create_or_refresh_task_for_action('publish')
+		end
+	end
+
+	describe ".tasks_for_action" do
+		it "responds to tasks_for_action" do
+			expect(taskable).to respond_to('tasks_for_action')
+		end
+
+		it "finds the tasks" do
+			taskable.save
+			task1 = taskable.tasks.create(action: 'create')
+			task2 = taskable.tasks.create(action: 'update')
+
+			expect(taskable.tasks_for_action('create')).to eq([task1])
+		end
+	end
+
+	describe ".last_task_for_action" do
+		it "responds to last_task_for_action" do
+			expect(taskable).to respond_to('last_task_for_action')
+		end
+
+		it "finds the task" do
+			taskable.save
+			task1 = taskable.tasks.create(taskable: taskable, action: 'create')
+			task2 = taskable.tasks.create(taskable: taskable, action: 'update')
+
+			res = taskable.last_task_for_action('create')
+			expect(res).to eq(task1)
+		end
+
+		it "returns nil if it cannot find the task" do
+			res = taskable.last_task_for_action('create')
+			expect(res).to be_nil
+		end
+	end
+
+	describe ".task_assignments" do
+		it "responds to task_assignments" do
+			expect(taskable).to respond_to('task_assignments')
+		end
+
+		it "finds the assignments" do
+			taskable.save
+			task1 = taskable.tasks.create(taskable: taskable, action: 'create')
+			task2 = taskable.tasks.create(taskable: taskable, action: 'update')
+			task1.assignments.create
+			task2.assignments.create
+			expect(taskable.task_assignments.size).to eq(2)
+		end
+	end
+
+	describe ".task_assignments_for_action" do
+		it "responds to task_assignments_for_action" do
+			expect(taskable).to respond_to('task_assignments_for_action')
+		end
+
+		it "finds the assignments" do
+			taskable.save
+			task1 = taskable.tasks.create(action: 'publish')
+			task2 = taskable.tasks.create(action: 'submit')
+			task1.assignments.create
+			task2.assignments.create
+			res = taskable.task_assignments_for_action('publish')
+			expect(res.size).to eq(1)
+		end
+
+		it "returns an empty array if if cannot find the task" do
+			res = taskable.task_assignments_for_action('review')
+			expect(res).to be_empty
+		end
+	end
+
+	describe ".task_assignment_for" do
+		it "requires an assignee" do
+			expect{ taskable.task_assignment_for('publish') }.to raise_error(ArgumentError)
+		end
+
+		it "calls assignment_for on task" do
+			task.should_receive(:assignment_for).with(assignee)
+			taskable.stub(:last_task_for_action).and_return(task)
+			taskable.task_assignment_for('publish', assignee)
+		end
+
+		it "returns nil if if cannot find the task" do
+			res = taskable.task_assignment_for('publish', assignee)
+			expect(res).to be_nil
+		end
+	end
+
+	describe ".complete_task_for_action" do
+
+		it "requires an action" do
+			expect{ taskable.complete_task_for_action }.to raise_error(ArgumentError)
+		end
+
+		it "calls complete! on the task" do
+			task = double.as_null_object
+			task.should_receive(:complete!)
+			taskable.stub(:last_task_for_action).and_return(task)
+			taskable.complete_task_for_action('publish')
+		end
+
+		it "return true" do
+			task = double.as_null_object
+			task.stub(:complete!).and_return(true)
+			taskable.stub(:last_task_for_action).and_return(task)
+			res = taskable.complete_task_for_action('publish')
+			expect(res).to be_true
+		end
+
+		it "returns false if it cannot find the task" do
+			res = taskable.complete_task_for_action('publish')
+			expect(res).to be_false
+		end
+	end
+
+	describe ".complete_task_for" do
+
+		it "requires an assignee" do
+			expect{ taskable.complete_task_for('publish') }.to raise_error(ArgumentError)
+		end
+
+		it "calls complete_by on task" do
+			task.should_receive(:complete_by).with(assignee)
+			taskable.stub(:last_task_for_action).and_return(task)
+			taskable.complete_task_for('publish', assignee)
+		end
+
+		it "returns true" do
+			task.stub(:complete_by).and_return(true)
+			taskable.stub(:last_task_for_action).and_return(task)
+			res = taskable.complete_task_for('publish', assignee)
+			expect(res).to be_true
+		end
+
+		it "returns false if it cannot find the task" do
+			res = taskable.complete_task_for('publish', assignee)
+			expect(res).to be_false
+		end
+	end
+
+	describe ".complete_tasks_for_action" do
+		it "returns false if it cannot find any tasks" do
+			res = taskable.complete_tasks_for_action('review')
+			expect(res).to be_false
+		end
+
+		it "sends complete! to all tasks" do
+			task1 = double.as_null_object
+			task2 = double.as_null_object
+			task1.should_receive(:complete!)
+			task2.should_receive(:complete!)
+			tasks = [task1, task2]
+			taskable.stub(:current_tasks_for_action).and_return(tasks)
+			res = taskable.complete_tasks_for_action('review')
+		end
+	end
+
+	describe ".expire_tasks_for_action" do
+		it "returns false if it cannot find any tasks" do
+			res = taskable.expire_tasks_for_action('review')
+			expect(res).to be_false
+		end
+
+		it "sends expire to all tasks" do
+			task1 = double.as_null_object
+			task2 = double.as_null_object
+			task1.should_receive(:expire)
+			task2.should_receive(:expire)
+			tasks = [task1, task2]
+			taskable.stub(:current_tasks_for_action).and_return(tasks)
+			res = taskable.expire_tasks_for_action('review')
+		end
+	end
+
+end

data/spec/be_taskable/unit/tasker_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe 'BeTaskable::Tasker' do
+
+	let(:user) { User.new }
+	let(:task) { BeTaskable::Task.new }
+
+	it "responds to tasker?" do
+		expect(user).to be_tasker
+	end
+
+	it "responds to task_assignments" do
+		expect(user).to respond_to(:task_assignments)
+	end
+
+	it "has task assignments" do
+		user.save
+		task.save
+		assignment = BeTaskable::TaskAssignment.create(task: task, assignee: user)
+
+		expect(user.task_assignments.size).to eq(1)
+	end
+
+end

data/spec/database.yml

@@ -0,0 +1,19 @@
+sqlite3:
+  adapter: sqlite3
+  database: be_taskable.sqlite3
+
+mysql:
+  adapter: mysql2
+  hostname: localhost
+  username: root
+  password:
+  database: be_taskable
+  charset: utf8
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: be_taskable
+  encoding: utf8

data/spec/models.rb

@@ -0,0 +1,38 @@
+class User < ActiveRecord::Base
+	be_tasker
+end
+
+class Taskable < ActiveRecord::Base
+	be_taskable
+end
+
+class TaskablePublishTaskResolver < BeTaskable::TaskResolver
+end
+
+class TaskableReviewTaskResolver < BeTaskable::TaskResolver
+
+	def consensus?(assignments)
+		false
+	end
+
+	def assignees_for_task(task)
+		[]
+	end
+
+	def due_date_for_assignment(assignment)
+		DateTime.now + 10.days
+	end
+
+	def label_for_task(task)
+		"Task label #{task.id}"
+	end
+
+	def label_for_assignment(assignment)
+		"Assignment label #{assignment.id}"
+	end
+
+	def url_for_assignment(assignment)
+		"Assignment url #{assignment.id}"
+	end
+
+end

data/spec/schema.rb

@@ -0,0 +1,37 @@
+ActiveRecord::Schema.define :version => 0 do
+
+	create_table 'users', force: true do |t|
+		t.timestamps
+	end
+
+	create_table 'taskables', force: true do |t|
+		t.timestamps
+	end
+
+	create_table 'be_taskable_tasks', force: true do |t|
+		t.string :action
+		t.string :state
+		t.integer :taskable_id
+		t.string :taskable_type
+		t.string :label
+		t.datetime :completed_at
+		t.datetime :expired_at
+		t.timestamps
+	end
+
+	create_table 'be_taskable_task_assignments', force: true do |t|
+		t.integer :task_id
+		t.integer :assignee_id
+		t.string :assignee_type
+		t.string :label
+		t.string :url
+		t.boolean :confirmed
+		t.boolean :enacted
+		t.datetime :visible_at
+		t.datetime :complete_by
+		t.datetime :completed_at
+		t.datetime :expired_at
+		t.timestamps
+	end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+# $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# $LOAD_PATH.unshift(File.dirname(__FILE__))
+# require 'gbg_tasks'
+
+$LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+require 'logger'
+require 'database_cleaner'
+require 'active_record'
+require 'action_view'
+require 'action_controller'
+require 'rspec/rails'
+require 'rspec-steps'
+
+# Make sure the right version of bundler is loaded
+begin
+	require "rubygems"
+	require "bundler"
+
+	if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.5")
+		raise RuntimeError, "Your bundler version is too old. Run `gem install bundler` to upgrade."
+	end
+
+# Set up load paths for all bundled gems
+Bundler.setup
+rescue Bundler::GemNotFound
+	raise RuntimeError, "Bundler couldn't find some gems. Did you run \`bundlee install\`?"
+end
+
+Bundler.require
+require File.expand_path('../../lib/be_taskable', __FILE__)
+
+# set adapter to use, default is sqlite3
+# to use an alternative adapter run => rake spec DB='postgresql'
+db_name = ENV['DB'] || 'sqlite3'
+database_yml = File.expand_path('../database.yml', __FILE__)
+
+# Load the data
+if File.exists?(database_yml)
+	active_record_configuration = YAML.load_file(database_yml)
+
+	ActiveRecord::Base.configurations = active_record_configuration
+	config = ActiveRecord::Base.configurations[db_name]
+
+	begin
+		ActiveRecord::Base.establish_connection(db_name)
+		ActiveRecord::Base.connection	
+	rescue
+		case db_name
+			when /mysql/
+				ActiveRecord::Base.establish_connection(config.merge('database' => nil))
+				ActiveRecord::Base.connection.create_database(config['database'],  {:charset => 'utf8', :collation => 'utf8_unicode_ci'})
+			when 'postgresql'
+				ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+				ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
+			end
+
+		ActiveRecord::Base.establish_connection(config)
+	end
+
+	ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+	ActiveRecord::Base.default_timezone = :utc
+
+	ActiveRecord::Base.silence do
+		ActiveRecord::Migration.verbose = false
+
+		load(File.dirname(__FILE__) + '/schema.rb')
+		load(File.dirname(__FILE__) + '/models.rb')
+	end
+
+else
+	raise "Please create #{database_yml} first to configure your database. Take a look at: #{database_yml}.sample"
+end
+
+RSpec.configure do |config|
+	config.treat_symbols_as_metadata_keys_with_true_values = true
+	config.fail_fast = true
+
+	# Run specs in random order to surface order dependencies. If you find an
+	# order dependency and want to debug it, you can fix the order by providing
+	# the seed, which is printed after each run.
+	#     --seed 1234
+	# config.order = "random"
+
+	config.before :suite do
+		DatabaseCleaner.strategy = :deletion
+	end
+
+	config.before(:each) do
+		DatabaseCleaner.start
+	end
+
+	config.after(:each) do
+		DatabaseCleaner.clean
+	end
+
+end