massive 0.1.0

data/spec/models/massive/locking_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+shared_examples_for Massive::Locking do
+  let(:redis) { Resque.redis }
+  let(:key)   { :some_key }
+
+  context "when there is a lock for the given key" do
+    let(:lock_key) { subject.send(:lock_key_for, key) }
+    before { redis.set(lock_key, 60) }
+
+    it { should be_locked(key) }
+
+    it "does not sets the an expiration for the key" do
+      redis.should_not_receive(:pexpire)
+      subject.locked?(key)
+    end
+  end
+
+  context "when there is no lock for the given key" do
+    let(:lock_key) { subject.send(:lock_key_for, key) }
+
+    it { should_not be_locked(key) }
+
+    context "and an expiration is not given for the locked key" do
+      it "sets the expiration to 60 seconds, specifying in miliseconds" do
+        redis.should_receive(:pexpire).with(lock_key, 60 * 1000)
+        subject.locked?(key)
+      end
+    end
+
+    context "and an expiration is given for the locked key" do
+      it "sets the expiration to this value" do
+        redis.should_receive(:pexpire).with(lock_key, 10)
+        subject.locked?(key, 10)
+      end
+    end
+
+    context "when pexpire command is not supported" do
+      let(:error) { Redis::CommandError.new('not supported') }
+      before { redis.stub(:pexpire).and_raise(error) }
+
+      it "should set expiration using expire command, dividing expiration per 1000 and rounding" do
+        redis.should_receive(:expire).with(lock_key, (1500/1000).to_i)
+        subject.locked?(key, 1500)
+      end
+    end
+  end
+end
+
+describe Massive::Step do
+  it_should_behave_like Massive::Locking
+end

data/spec/models/massive/memory_consumption_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+shared_examples_for Massive::MemoryConsumption do
+  let(:memory) { 123456 }
+  let(:io) { double(IO, gets: "    #{memory} ") }
+  before { IO.stub(:popen).with("ps -o rss= -p #{Process.pid}").and_yield(io) }
+
+  its(:current_memory_consumption) { should eq(memory) }
+
+  context "and an error is raised" do
+    let(:error) { StandardError.new('some error') }
+    before { IO.stub(:popen).with("ps -o rss= -p #{Process.pid}").and_raise(error) }
+
+    its(:current_memory_consumption) { should be_zero }
+  end
+end
+
+describe Massive::Step do
+  it_should_behave_like Massive::MemoryConsumption
+end
+
+describe Massive::Job do
+  it_should_behave_like Massive::MemoryConsumption
+end

data/spec/models/massive/notifications_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+shared_examples_for Massive::Notifications do
+  its(:notifier_id) { should eq("#{described_class.name.underscore.gsub('/', '-')}-#{notifyable.id}") }
+
+  after do
+    described_class.notifier(:base, {}) # resetting notifier
+  end
+
+  describe "#notify(message)" do
+    let(:message) { :some_message }
+    let(:serializer) { notifyable.active_model_serializer.new(notifyable) }
+
+    it "notifies the message" do
+      notifyable.notifier.should_receive(:notify).with(message)
+      notifyable.notify(message)
+    end
+
+    it "sends a serialized version of itself, after reloading itself, as data" do
+      notifyable.save
+      notifyable.notify(message)
+      notifyable.notifier.last[:data].as_json.should eq(serializer.as_json)
+    end
+
+    context "when there is no serializer for the step" do
+      before { notifyable.stub(:active_model_serializer).and_return(nil) }
+
+      it "does not sends the notification" do
+        notifyable.notifier.should_not_receive(:notify)
+        notifyable.notify(message)
+      end
+    end
+  end
+
+  describe "#notifier" do
+    let(:options) { { expiration: 200, foo: 'bar', other: 'yup' } }
+
+    it "returns an instance of the notifier" do
+      notifyable.notifier.should be_a(Massive::Notifiers::Base)
+    end
+
+    it "passes notifier options when creating the notifier" do
+      described_class.notifier :base, options
+      notifyable.notifier.options.should eq(options)
+    end
+
+    it "creates it with the notifier_id" do
+      notifyable.notifier.id.should eq(notifyable.notifier_id)
+    end
+  end
+
+  describe ".notifier" do
+    context "when a parameter is given" do
+      context "as a symbol" do
+        it "returns a notifier class from Massive::Notifiers::<given_symbol.camelized>" do
+          described_class.notifier :pusher
+          described_class.notifier_class.should eq(Massive::Notifiers::Pusher)
+        end
+
+        context "and others parameters are given" do
+          let(:options) { { expiration: 200, foo: 'bar', other: 'yup' } }
+
+          it "store these parameters to be used when creating the notifier" do
+            described_class.notifier :pusher, options
+            described_class.notifier_options.should eq(options)
+          end
+        end
+      end
+
+      context "as a Class" do
+        it "configures the notifier, using the symbol to get the class" do
+          described_class.notifier(Massive::Notifiers::Pusher)
+          described_class.notifier_class.should eq(Massive::Notifiers::Pusher)
+        end
+
+        context "and others parameters are given" do
+          let(:options) { { expiration: 200, foo: 'bar', other: 'yup' } }
+
+          it "passes these parameters when creating the notifier" do
+            described_class.notifier(Massive::Notifiers::Pusher, options)
+            described_class.notifier_options.should eq(options)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Massive::Step do
+  let(:process) { Massive::Process.new }
+  subject(:notifyable) { process.steps.build }
+
+  it_should_behave_like Massive::Notifications
+end
+
+describe Massive::Job do
+  let(:process) { Massive::Process.new }
+  let(:step) { process.steps.build }
+  subject(:job) { step.jobs.build }
+
+  let(:message) { 'some message' }
+
+  it "delegates #notify to the step" do
+    step.should_receive(:notify).with(message)
+    job.notify(message)
+  end
+end

data/spec/models/massive/notifiers/base_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Massive::Notifiers::Base do
+  let(:id) { 'some-id' }
+  subject(:notifier) { Massive::Notifiers::Base.new(id) }
+
+  it_should_behave_like Massive::Locking
+
+  describe "#notify(message, data)" do
+    let(:redis) { Resque.redis }
+
+    let(:message) { :some_message }
+    let(:data)    { { some: 'data' } }
+
+    context "when a notification for this message is not locked" do
+      it "sends a notification" do
+        notifier.notify(message, data)
+        notifier.last[:message].should eq(message)
+        notifier.last[:data].should eq(data)
+      end
+
+      context "when a block is given" do
+        it "sends a notification with the data being the return from the block" do
+          notifier.notify(message) { data }
+          notifier.last[:message].should eq(message)
+          notifier.last[:data].should eq(data)
+        end
+      end
+    end
+
+    context "when a notification for this message is locked" do
+      let(:lock_key) { subject.send(:lock_key_for, message) }
+      before { redis.set(lock_key, 60) }
+
+      it "does not send a notification" do
+        notifier.notify(message, data)
+        notifier.last[:message].should be_nil
+        notifier.last[:data].should be_nil
+      end
+
+      context "when a block is given" do
+        it "does not execute the block" do
+          notifier.notify(message) { fail('should not execute this block') }
+        end
+      end
+    end
+  end
+end

data/spec/models/massive/notifiers/pusher_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Massive::Notifiers::Pusher do
+  let(:id) { 'pusher_notifier' }
+
+  let(:client)       { double('Pusher') }
+  subject(:notifier) { Massive::Notifiers::Pusher.new(id, client: client) }
+
+  it_should_behave_like Massive::Locking
+
+  it { should be_a(Massive::Notifiers::Base) }
+
+  describe "#notify(message, data)" do
+    let(:redis) { Resque.redis }
+
+    let(:message) { :some_message }
+    let(:data)    { { some: 'data' } }
+
+    context "when a notification for this message is not locked" do
+      it "sends a notification" do
+        client.should_receive(:trigger).with(id, message, data)
+        notifier.notify(message, data)
+      end
+
+      context "when a block is given" do
+        it "sends a notification with the data being the return from the block" do
+          client.should_receive(:trigger).with(id, message, data)
+          notifier.notify(message) { data }
+        end
+      end
+    end
+
+    context "when a notification for this message is locked" do
+      let(:lock_key) { subject.send(:lock_key_for, message) }
+      before { redis.set(lock_key, 60) }
+
+      it "does not send a notification" do
+        client.should_not_receive(:trigger)
+        notifier.notify(message, data)
+      end
+
+      context "when a block is given" do
+        it "does not execute the block" do
+          notifier.notify(message) { fail('should not execute this block') }
+        end
+      end
+    end
+  end
+end

data/spec/models/massive/process_serializer_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Massive::ProcessSerializer do
+  let(:process) { Massive::Process.new }
+  subject(:serialized) { described_class.new(process).as_json(root: false) }
+
+  it "serializes process id as string" do
+    serialized[:id].should eq(process.id.to_s)
+  end
+
+  [:created_at, :updated_at].each do |field|
+    it "serializes the #{field}" do
+      process[field] = 1.minute.ago
+      serialized[field].should eq(process[field])
+    end
+  end
+
+  it "serializes the processed percentage" do
+    process.stub(:processed_percentage).and_return(12)
+    serialized[:processed_percentage].should eq(process.processed_percentage)
+  end
+
+  context "when it is completed" do
+    before { process.stub(:completed?).and_return(true) }
+
+    it "serializes completed" do
+      serialized[:completed].should be_true
+    end
+  end
+
+  context "when it is not completed" do
+    before { process.stub(:completed?).and_return(false) }
+
+    it "serializes completed" do
+      serialized[:completed].should be_false
+    end
+  end
+end

data/spec/models/massive/process_spec.rb

@@ -0,0 +1,235 @@
+require "spec_helper"
+
+describe Massive::Process do
+  subject(:process) { Massive::Process.new }
+
+  describe "#enqueue_next" do
+    context "when there are steps" do
+      let!(:first_step) { process.steps.build }
+      let!(:second_step) { process.steps.build }
+      let!(:third_step) { process.steps.build }
+
+      context "and none of them are completed" do
+        it "enqueues the first step" do
+          first_step.should_receive(:enqueue)
+          process.enqueue_next
+        end
+
+        it "does not enqueue the other steps" do
+          second_step.should_not_receive(:enqueue)
+          third_step.should_not_receive(:enqueue)
+          process.enqueue_next
+        end
+      end
+
+      context "and the first one is completed, but the second one is not" do
+        before { first_step.finished_at = Time.now }
+
+        it "does not enqueue the first step" do
+          first_step.should_not_receive(:enqueue)
+          process.enqueue_next
+        end
+
+        it "enqueues the second step" do
+          second_step.should_receive(:enqueue)
+          process.enqueue_next
+        end
+
+        it "does not enqueue the third step" do
+          third_step.should_not_receive(:enqueue)
+          process.enqueue_next
+        end
+      end
+
+      context "and the first one is enqueued" do
+        before { first_step.stub(:enqueued?).and_return(true) }
+
+        it "does not enqueue the next step" do
+          second_step.should_not_receive(:enqueue)
+          process.enqueue_next
+        end
+      end
+
+      context "but all of them are completed" do
+        before do
+          process.steps.each do |step|
+            step.finished_at = Time.now
+          end
+        end
+
+        it "does not enqueue any of the steps" do
+          process.steps.each do |step|
+            step.should_not_receive(:enqueue)
+          end
+
+          process.enqueue_next
+        end
+      end
+    end
+  end
+
+  describe "#next_step" do
+    let!(:step) { process.steps.build }
+
+    context "when the step is enqueued" do
+      before { step.stub(:enqueued?).and_return(true) }
+
+      its(:next_step) { should be_nil }
+    end
+
+    context "when the step is not enqueued" do
+      its(:next_step) { should eq step }
+    end
+  end
+
+  describe ".find_step" do
+    let!(:step) { process.steps.build }
+
+    before { process.save }
+
+    it "returns the step with id within the process" do
+      Massive::Process.find_step(process.id, step.id).should eq(step)
+    end
+  end
+
+  describe ".find_job" do
+    let!(:step) { process.steps.build }
+    let!(:job)  { step.jobs.build }
+
+    before { process.save }
+
+    it "returns the job with id within the step of the process" do
+      Massive::Process.find_job(process.id, step.id, job.id).should eq(job)
+    end
+  end
+
+  describe "#processed_percentage" do
+    let(:step_1)  { process.steps.build(weight: 9) }
+    let(:step_2)  { process.steps.build            }
+
+    context "when the process have not started" do
+      before do
+        step_1.stub(:processed_percentage).and_return(0)
+        step_2.stub(:processed_percentage).and_return(0)
+      end
+
+      its(:processed_percentage) { should eq 0 }
+    end
+
+    context "when the process have finished" do
+      before do
+        step_1.stub(:processed_percentage).and_return(1)
+        step_2.stub(:processed_percentage).and_return(1)
+      end
+
+      its(:processed_percentage) { should eq 1 }
+    end
+
+    context "when the file export step is finished" do
+      before { step_1.stub(:processed_percentage).and_return(1) }
+
+      context "and the file upload step is not finished" do
+        before { step_2.stub(:processed_percentage).and_return(0) }
+
+        its(:processed_percentage) { should eq 0.9 }
+      end
+    end
+
+    context "when the file export step is finished" do
+      before { step_1.stub(:processed_percentage).and_return(1) }
+
+      context "and the file upload step is finished" do
+        before { step_2.stub(:processed_percentage).and_return(1) }
+
+        its(:processed_percentage) { should eq 1 }
+      end
+    end
+
+    context "when the file export step is finished" do
+      before { step_1.stub(:processed_percentage).and_return(1) }
+
+      context "and the file upload step is half way to be finished" do
+        before { step_2.stub(:processed_percentage).and_return(0.5) }
+
+        its(:processed_percentage) { should eq 0.95 }
+      end
+    end
+
+    context "when the total weight of the steps is zero" do
+      let(:step_1)  { process.steps.build(weight: 0) }
+      let(:step_2)  { process.steps.build(weight: 0) }
+
+      its(:processed_percentage) { should eq 0 }
+    end
+  end
+
+  describe "#completed?" do
+    let!(:step_1)  { process.steps.build }
+    let!(:step_2)  { process.steps.build }
+
+    before { process.save }
+
+    context "when the steps are incompleted steps" do
+      its(:completed?) { should be_false }
+    end
+
+    context "when therere are no incompleted steps" do
+      before do
+        step_1.update_attributes(finished_at: Time.now, failed_at: nil)
+        step_2.update_attributes(finished_at: Time.now, failed_at: nil)
+      end
+
+      its(:completed?) { should be_true }
+    end
+  end
+
+  describe "#cancel" do
+    let!(:now) do
+      Time.now.tap do |now|
+        Time.stub(:now).and_return(now)
+      end
+    end
+
+    it "sets cancelled_at to the current time, persisting it" do
+      process.cancel
+      process.reload.cancelled_at.to_i.should eq(now.to_i)
+    end
+
+    it "sets a cancelled key in redis with the process id" do
+      process.cancel
+      Massive.redis.exists("#{process.class.name.underscore}:#{process.id}:cancelled").should be_true
+    end
+  end
+
+  describe "#canceled?" do
+    context "when it has a cancelled_at" do
+      before { process.cancelled_at = Time.now }
+
+      it { should be_cancelled }
+    end
+
+    context "when it doesn't have a cancelled_at" do
+      it { should_not be_cancelled }
+
+      context "but there is a cancelled key for this process in redis" do
+        before { Massive.redis.set("#{process.class.name.underscore}:#{process.id}:cancelled", true) }
+
+        it { should be_cancelled }
+      end
+    end
+  end
+
+  describe "#active_model_serializer" do
+    its(:active_model_serializer) { should eq Massive::ProcessSerializer }
+
+    context "when class inherits from Massive::Process and does not have a serializer" do
+      class TestProcess < Massive::Process
+      end
+
+      it "returns Massive::ProcessSerializer" do
+        process = TestProcess.new
+        process.active_model_serializer.should eq Massive::ProcessSerializer
+      end
+    end
+  end
+end